@reactionary/fake 0.6.3

package/README.md

@@ -0,0 +1,11 @@
+# fake
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build fake` to build the library.
+
+## Running unit tests
+
+Run `nx test fake` to execute the unit tests via [Vitest](https://vitest.dev/).

package/capabilities/analytics.capability.js

@@ -0,0 +1,15 @@
+import {
+  AnalyticsCapability
+} from "@reactionary/core";
+class FakeAnalyticsCapability extends AnalyticsCapability {
+  config;
+  constructor(config, cache, context) {
+    super(cache, context);
+    this.config = config;
+  }
+  async track(event) {
+  }
+}
+export {
+  FakeAnalyticsCapability
+};

package/capabilities/cart.capability.js

@@ -0,0 +1,261 @@
+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 {
+  CartIdentifierSchema,
+  CartMutationApplyCouponSchema,
+  CartMutationChangeCurrencySchema,
+  CartMutationDeleteCartSchema,
+  CartMutationItemAddSchema,
+  CartMutationItemQuantityChangeSchema,
+  CartMutationItemRemoveSchema,
+  CartMutationRemoveCouponSchema,
+  CartCapability,
+  CartQueryByIdSchema,
+  CartSchema,
+  Reactionary,
+  error,
+  success,
+  unwrapValue
+} from "@reactionary/core";
+import { Faker, en, base } from "@faker-js/faker";
+class FakeCartCapability extends CartCapability {
+  config;
+  factory;
+  carts = /* @__PURE__ */ new Map();
+  generator;
+  constructor(config, cache, context, factory) {
+    super(cache, context);
+    this.generator = new Faker({
+      locale: [en, base],
+      seed: config.seeds.product
+    });
+    this.config = config;
+    this.factory = factory;
+  }
+  async getById(payload) {
+    const cartId = payload.cart.key;
+    if (payload.cart.key === "") {
+      return error({
+        type: "NotFound",
+        identifier: cartId
+      });
+    }
+    if (!this.carts.has(cartId)) {
+      const cart2 = this.createEmptyCart();
+      cart2.identifier.key = cartId;
+      this.carts.set(cartId, cart2);
+    }
+    const cart = this.carts.get(cartId);
+    if (!cart) {
+      throw new Error(`Cart with id ${cartId} not found`);
+    }
+    return success(this.factory.parseCart(this.context, cart));
+  }
+  async add(payload) {
+    const cartId = payload?.cart?.key || `cart-${this.generator.string.uuid()}`;
+    const cart = unwrapValue(await this.getById({ cart: { key: cartId } }));
+    if (cart.identifier.key === "") {
+      cart.identifier.key = cartId;
+      this.carts.set(cartId, cart);
+    }
+    const existingItemIndex = cart.items.findIndex(
+      (item) => item.variant.sku === payload.variant.sku
+    );
+    if (existingItemIndex >= 0) {
+      cart.items[existingItemIndex].quantity += payload.quantity;
+    } else {
+      const price = this.generator.number.int({ min: 100, max: 1e5 }) / 100;
+      cart.items.push({
+        identifier: { key: `item-${Date.now()}` },
+        variant: payload.variant,
+        quantity: payload.quantity,
+        price: {
+          unitPrice: {
+            value: price,
+            currency: this.context.languageContext.currencyCode
+          },
+          totalPrice: {
+            value: 0,
+            // Will be calculated below
+            currency: this.context.languageContext.currencyCode
+          },
+          totalDiscount: {
+            value: 0,
+            currency: this.context.languageContext.currencyCode
+          },
+          unitDiscount: {
+            value: 0,
+            currency: this.context.languageContext.currencyCode
+          }
+        },
+        product: {
+          key: `product-for-${payload.variant.sku}`
+        }
+      });
+    }
+    this.recalculateCart(cart);
+    return success(this.factory.parseCart(this.context, cart));
+  }
+  async remove(payload) {
+    const cartId = payload.cart.key || `cart-${this.generator.string.uuid()}`;
+    const cart = unwrapValue(await this.getById({ cart: { key: cartId } }));
+    cart.items = cart.items.filter(
+      (item) => item.identifier.key !== payload.item.key
+    );
+    this.recalculateCart(cart);
+    return success(this.factory.parseCart(this.context, cart));
+  }
+  async changeQuantity(payload) {
+    const cartId = payload.cart.key || `cart-${this.generator.string.uuid()}`;
+    const cart = unwrapValue(await this.getById({ cart: { key: cartId } }));
+    const item = cart.items.find(
+      (item2) => item2.identifier.key === payload.item.key
+    );
+    if (payload.quantity < 1) {
+      return success(this.factory.parseCart(this.context, cart));
+    }
+    if (item) {
+      item.quantity = payload.quantity;
+    }
+    this.recalculateCart(cart);
+    return success(this.factory.parseCart(this.context, cart));
+  }
+  getActiveCartId() {
+    throw new Error("Method not implemented.");
+  }
+  deleteCart(payload) {
+    throw new Error("Method not implemented.");
+  }
+  applyCouponCode(payload) {
+    throw new Error("Method not implemented.");
+  }
+  removeCouponCode(payload) {
+    throw new Error("Method not implemented.");
+  }
+  changeCurrency(payload) {
+    throw new Error("Method not implemented.");
+  }
+  recalculateCart(cart) {
+    cart.items.forEach((item) => {
+      item.price.totalPrice.value = item.price.unitPrice.value * item.quantity;
+    });
+    cart.price.totalProductPrice = {
+      value: cart.items.reduce(
+        (sum, item) => sum + item.price.totalPrice.value,
+        0
+      ),
+      currency: cart.items[0]?.price.unitPrice.currency || "USD"
+    };
+    cart.price.grandTotal = {
+      value: cart.items.reduce(
+        (sum, item) => sum + item.price.totalPrice.value,
+        0
+      ),
+      currency: cart.items[0]?.price.unitPrice.currency || "USD"
+    };
+  }
+  createEmptyCart() {
+    const cart = {
+      identifier: { key: "" },
+      description: "",
+      items: [],
+      name: "",
+      price: {
+        grandTotal: {
+          value: 0,
+          currency: "XXX"
+        },
+        totalDiscount: {
+          value: 0,
+          currency: "XXX"
+        },
+        totalProductPrice: {
+          value: 0,
+          currency: "XXX"
+        },
+        totalShipping: {
+          value: 0,
+          currency: "XXX"
+        },
+        totalSurcharge: {
+          value: 0,
+          currency: "XXX"
+        },
+        totalTax: {
+          value: 0,
+          currency: "XXX"
+        }
+      },
+      appliedPromotions: [],
+      userId: {
+        userId: ""
+      }
+    };
+    return cart;
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: CartQueryByIdSchema,
+    outputSchema: CartSchema
+  })
+], FakeCartCapability.prototype, "getById", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationItemAddSchema,
+    outputSchema: CartSchema
+  })
+], FakeCartCapability.prototype, "add", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationItemRemoveSchema,
+    outputSchema: CartSchema
+  })
+], FakeCartCapability.prototype, "remove", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationItemQuantityChangeSchema,
+    outputSchema: CartSchema
+  })
+], FakeCartCapability.prototype, "changeQuantity", 1);
+__decorateClass([
+  Reactionary({
+    outputSchema: CartIdentifierSchema
+  })
+], FakeCartCapability.prototype, "getActiveCartId", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationDeleteCartSchema,
+    outputSchema: CartSchema
+  })
+], FakeCartCapability.prototype, "deleteCart", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationApplyCouponSchema,
+    outputSchema: CartSchema
+  })
+], FakeCartCapability.prototype, "applyCouponCode", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationRemoveCouponSchema,
+    outputSchema: CartSchema
+  })
+], FakeCartCapability.prototype, "removeCouponCode", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationChangeCurrencySchema,
+    outputSchema: CartSchema
+  })
+], FakeCartCapability.prototype, "changeCurrency", 1);
+export {
+  FakeCartCapability
+};

package/capabilities/category.capability.js

@@ -0,0 +1,160 @@
+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 {
+  CategoryPaginatedResultSchema,
+  CategoryCapability,
+  CategoryQueryByIdSchema,
+  CategoryQueryBySlugSchema,
+  CategoryQueryForBreadcrumbSchema,
+  CategoryQueryForChildCategoriesSchema,
+  CategoryQueryForTopCategoriesSchema,
+  CategorySchema,
+  Reactionary,
+  error,
+  success
+} from "@reactionary/core";
+import * as z from "zod";
+import { Faker, en, base } from "@faker-js/faker";
+class FakeCategoryCapability extends CategoryCapability {
+  config;
+  factory;
+  topCategories = [];
+  childCategories = /* @__PURE__ */ new Map();
+  allCategories = /* @__PURE__ */ new Map();
+  categoryGenerator;
+  generateFakeCategory(parent, index) {
+    const name = parent ? `${parent.name}-${index}` : this.categoryGenerator.commerce.department();
+    const identifier = { key: name.toLowerCase().replace(/\s+/g, "-") };
+    const category = {
+      identifier,
+      images: [],
+      name,
+      slug: `${identifier.key}-slug`,
+      text: this.categoryGenerator.lorem.sentences(3),
+      parentCategory: parent?.identifier
+    };
+    this.allCategories.set(identifier.key, category);
+    return category;
+  }
+  constructor(config, cache, context, factory) {
+    super(cache, context);
+    this.config = config;
+    this.factory = factory;
+    this.categoryGenerator = new Faker({
+      seed: this.config.seeds.category,
+      locale: [en, base]
+    });
+    for (let i = 0; i < 6; i++) {
+      this.topCategories.push(this.generateFakeCategory(void 0, i));
+    }
+    this.topCategories.forEach((parentCategory) => {
+      const children = [];
+      for (let j = 0; j < 5; j++) {
+        const childCategory = this.generateFakeCategory(parentCategory, j);
+        children.push(childCategory);
+        const subCategoryChildren = [];
+        for (let k = 0; k < 5; k++) {
+          subCategoryChildren.push(this.generateFakeCategory(childCategory, k));
+        }
+        this.childCategories.set(childCategory.identifier.key, subCategoryChildren);
+      }
+      this.childCategories.set(parentCategory.identifier.key, children);
+    });
+  }
+  async getById(payload) {
+    const category = this.allCategories.get(payload.id.key);
+    if (!category) {
+      return error({
+        type: "NotFound",
+        identifier: payload
+      });
+    }
+    return success(this.factory.parseCategory(this.context, category));
+  }
+  async getBySlug(payload) {
+    for (const category of this.allCategories.values()) {
+      if (category.slug === payload.slug) {
+        return success(this.factory.parseCategory(this.context, category));
+      }
+    }
+    return error({
+      type: "NotFound",
+      identifier: payload
+    });
+  }
+  async getBreadcrumbPathToCategory(payload) {
+    const path = [];
+    let next = this.allCategories.get(payload.id.key);
+    while (next) {
+      path.unshift(next);
+      if (!next.parentCategory) {
+        break;
+      }
+      next = this.allCategories.get(next.parentCategory.key);
+    }
+    return success(path.map((x) => this.factory.parseCategory(this.context, x)));
+  }
+  async findTopCategories(_payload) {
+    const result = {
+      items: this.topCategories,
+      pageSize: this.topCategories.length,
+      pageNumber: 1,
+      totalCount: this.topCategories.length,
+      totalPages: 1
+    };
+    return success(this.factory.parseCategoryPaginatedResult(this.context, result));
+  }
+  async findChildCategories(payload) {
+    const items = this.childCategories.get(payload.parentId.key) || [];
+    const result = {
+      items,
+      pageSize: items.length,
+      pageNumber: 1,
+      totalCount: items.length,
+      totalPages: 1
+    };
+    return success(this.factory.parseCategoryPaginatedResult(this.context, result));
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: CategoryQueryByIdSchema,
+    outputSchema: CategorySchema
+  })
+], FakeCategoryCapability.prototype, "getById", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CategoryQueryBySlugSchema,
+    outputSchema: CategorySchema
+  })
+], FakeCategoryCapability.prototype, "getBySlug", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CategoryQueryForBreadcrumbSchema,
+    outputSchema: z.array(CategorySchema)
+  })
+], FakeCategoryCapability.prototype, "getBreadcrumbPathToCategory", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CategoryQueryForTopCategoriesSchema,
+    outputSchema: CategoryPaginatedResultSchema
+  })
+], FakeCategoryCapability.prototype, "findTopCategories", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CategoryQueryForChildCategoriesSchema,
+    outputSchema: CategoryPaginatedResultSchema
+  })
+], FakeCategoryCapability.prototype, "findChildCategories", 1);
+export {
+  FakeCategoryCapability
+};

package/capabilities/checkout.capability.js

@@ -0,0 +1,231 @@
+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 {
+  CheckoutCapability,
+  Reactionary,
+  CheckoutMutationInitiateCheckoutSchema,
+  CheckoutSchema,
+  CheckoutQueryByIdSchema,
+  CheckoutMutationSetShippingAddressSchema,
+  CheckoutQueryForAvailableShippingMethodsSchema,
+  CheckoutQueryForAvailablePaymentMethodsSchema,
+  CheckoutMutationAddPaymentInstructionSchema,
+  CheckoutMutationRemovePaymentInstructionSchema,
+  CheckoutMutationSetShippingInstructionSchema,
+  CheckoutMutationFinalizeCheckoutSchema,
+  success,
+  PaymentMethodSchema,
+  ShippingMethodSchema
+} from "@reactionary/core";
+import { base, en, Faker } from "@faker-js/faker";
+import * as z from "zod";
+class FakeCheckoutCapability extends CheckoutCapability {
+  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 initiateCheckoutForCart(payload) {
+    const checkout = this.composeBaseCheckout(payload.cart.identifier);
+    return success(this.factory.parseCheckout(this.context, checkout));
+  }
+  async getById(payload) {
+    const checkout = this.composeBaseCheckout(payload.identifier);
+    return success(this.factory.parseCheckout(this.context, checkout));
+  }
+  async setShippingAddress(payload) {
+    const checkout = this.composeBaseCheckout(payload.checkout);
+    return success(this.factory.parseCheckout(this.context, checkout));
+  }
+  async getAvailableShippingMethods(payload) {
+    const methods = [
+      {
+        name: "Fake",
+        deliveryTime: "3 days",
+        description: "A fake delivery by fake mail",
+        identifier: {
+          key: "fake-001"
+        },
+        price: {
+          currency: "USD",
+          value: 500
+        },
+        carrier: "Faker"
+      }
+    ];
+    return success(
+      methods.map((method) => this.factory.parseShippingMethod(this.context, method))
+    );
+  }
+  async getAvailablePaymentMethods(payload) {
+    const methods = [
+      {
+        description: "A fake payment method for paying at some point",
+        identifier: {
+          method: "PayLater",
+          name: "Pay Later",
+          paymentProcessor: "Faker"
+        },
+        isPunchOut: false
+      }
+    ];
+    return success(
+      methods.map((method) => this.factory.parsePaymentMethod(this.context, method))
+    );
+  }
+  async addPaymentInstruction(payload) {
+    const checkout = this.composeBaseCheckout(payload.checkout);
+    return success(this.factory.parseCheckout(this.context, checkout));
+  }
+  async removePaymentInstruction(payload) {
+    const checkout = this.composeBaseCheckout(payload.checkout);
+    return success(this.factory.parseCheckout(this.context, checkout));
+  }
+  async setShippingInstruction(payload) {
+    const checkout = this.composeBaseCheckout(payload.checkout);
+    return success(this.factory.parseCheckout(this.context, checkout));
+  }
+  async finalizeCheckout(payload) {
+    const checkout = this.composeBaseCheckout(payload.checkout);
+    return success(this.factory.parseCheckout(this.context, checkout));
+  }
+  composeBaseCheckout(identifier) {
+    const checkout = {
+      description: "Fake Checkout",
+      identifier: identifier || {
+        key: this.generator.string.uuid()
+      },
+      items: [],
+      name: "Fake Checkout",
+      originalCartReference: {
+        key: this.generator.string.uuid()
+      },
+      paymentInstructions: [],
+      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
+          })
+        }
+      },
+      readyForFinalization: false
+    };
+    return checkout;
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutMutationInitiateCheckoutSchema,
+    outputSchema: CheckoutSchema
+  })
+], FakeCheckoutCapability.prototype, "initiateCheckoutForCart", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutQueryByIdSchema,
+    outputSchema: CheckoutSchema
+  })
+], FakeCheckoutCapability.prototype, "getById", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutMutationSetShippingAddressSchema,
+    outputSchema: CheckoutSchema
+  })
+], FakeCheckoutCapability.prototype, "setShippingAddress", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutQueryForAvailableShippingMethodsSchema,
+    outputSchema: z.array(ShippingMethodSchema)
+  })
+], FakeCheckoutCapability.prototype, "getAvailableShippingMethods", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutQueryForAvailablePaymentMethodsSchema,
+    outputSchema: z.array(PaymentMethodSchema)
+  })
+], FakeCheckoutCapability.prototype, "getAvailablePaymentMethods", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutMutationAddPaymentInstructionSchema,
+    outputSchema: CheckoutSchema
+  })
+], FakeCheckoutCapability.prototype, "addPaymentInstruction", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutMutationRemovePaymentInstructionSchema,
+    outputSchema: CheckoutSchema
+  })
+], FakeCheckoutCapability.prototype, "removePaymentInstruction", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutMutationSetShippingInstructionSchema,
+    outputSchema: CheckoutSchema
+  })
+], FakeCheckoutCapability.prototype, "setShippingInstruction", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutMutationFinalizeCheckoutSchema,
+    outputSchema: CheckoutSchema
+  })
+], FakeCheckoutCapability.prototype, "finalizeCheckout", 1);
+export {
+  FakeCheckoutCapability
+};