@reactionary/fake 0.6.3

package/capabilities/product-search.capability.js

@@ -0,0 +1,145 @@
+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 {
+  ImageSchema,
+  ProductSearchCapability,
+  ProductSearchQueryByTermSchema,
+  ProductSearchResultItemSchema,
+  ProductSearchResultSchema,
+  Reactionary,
+  success
+} from "@reactionary/core";
+import { Faker, en, base } from "@faker-js/faker";
+import { jitter } from "../utilities/jitter.js";
+class FakeProductSearchCapability extends ProductSearchCapability {
+  config;
+  factory;
+  constructor(config, cache, context, factory) {
+    super(cache, context);
+    this.config = config;
+    this.factory = factory;
+  }
+  async queryByTerm(payload) {
+    await jitter(this.config.jitter.mean, this.config.jitter.deviation);
+    const query = payload.search;
+    const querySpecificity = 20 - query.term.length - query.paginationOptions.pageNumber - query.facets.length;
+    const totalProducts = 10 * querySpecificity;
+    const totalPages = Math.ceil(totalProducts / query.paginationOptions.pageSize);
+    const productsOnPage = Math.min(totalProducts, query.paginationOptions.pageSize);
+    const productGenerator = new Faker({
+      seed: querySpecificity,
+      locale: [en, base]
+    });
+    const facetGenerator = new Faker({
+      seed: 100,
+      locale: [en, base]
+    });
+    const products = [];
+    const facets = [];
+    for (let i = 0; i < productsOnPage; i++) {
+      const srcUrl = productGenerator.image.urlPicsumPhotos({
+        height: 300,
+        width: 300,
+        grayscale: true,
+        blur: 8
+      });
+      const img = ImageSchema.parse({
+        sourceUrl: srcUrl,
+        altText: "Fake product image",
+        height: 300,
+        width: 300
+      });
+      products.push(
+        ProductSearchResultItemSchema.parse({
+          identifier: {
+            key: `product_${productGenerator.commerce.isbn()}`
+          },
+          name: productGenerator.commerce.productName(),
+          slug: productGenerator.lorem.slug(),
+          variants: [
+            {
+              variant: {
+                sku: productGenerator.commerce.isbn()
+              },
+              image: img,
+              options: void 0
+            }
+          ]
+        })
+      );
+    }
+    for (const baseFacet of ["color", "size"]) {
+      const facet = {
+        identifier: {
+          key: baseFacet
+        },
+        name: baseFacet,
+        values: []
+      };
+      for (let i = 0; i < 10; i++) {
+        const valueKey = i.toString();
+        const isActive = query.facets.find(
+          (x) => x.facet.key === facet.identifier.key && x.key === valueKey
+        ) !== void 0;
+        facet.values.push({
+          active: isActive,
+          count: facetGenerator.number.int({ min: 1, max: 50 }),
+          identifier: {
+            facet: {
+              key: facet.identifier.key
+            },
+            key: valueKey
+          },
+          name: facetGenerator.color.human()
+        });
+      }
+      facets.push(facet);
+    }
+    const result = {
+      identifier: {
+        term: query.term,
+        paginationOptions: {
+          pageNumber: query.paginationOptions.pageNumber,
+          pageSize: query.paginationOptions.pageSize
+        },
+        facets: query.facets,
+        filters: []
+      },
+      facets,
+      items: products,
+      pageNumber: query.paginationOptions.pageNumber,
+      pageSize: query.paginationOptions.pageSize,
+      totalCount: totalProducts,
+      totalPages
+    };
+    return success(this.factory.parseSearchResult(this.context, result, payload));
+  }
+  async createCategoryNavigationFilter(payload) {
+    const facetIdentifier = {
+      key: "category"
+    };
+    const facetValueIdentifier = {
+      facet: facetIdentifier,
+      key: payload.categoryPath[payload.categoryPath.length - 1].identifier.key
+    };
+    return success(facetValueIdentifier);
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: ProductSearchQueryByTermSchema,
+    outputSchema: ProductSearchResultSchema
+  })
+], FakeProductSearchCapability.prototype, "queryByTerm", 1);
+export {
+  FakeProductSearchCapability
+};

package/capabilities/product.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 {
+  ProductQueryByIdSchema,
+  ProductQueryBySKUSchema,
+  ProductQueryBySlugSchema,
+  ProductCapability,
+  ProductSchema,
+  Reactionary,
+  success
+} from "@reactionary/core";
+import { base, en, Faker } from "@faker-js/faker";
+class FakeProductCapability extends ProductCapability {
+  config;
+  factory;
+  constructor(config, cache, context, factory) {
+    super(cache, context);
+    this.config = config;
+    this.factory = factory;
+  }
+  async getById(payload) {
+    return success(this.composeSingle(payload.identifier.key));
+  }
+  async getBySlug(payload) {
+    return success(this.composeSingle(payload.slug));
+  }
+  async getBySKU(payload) {
+    return success(this.composeSingle(payload.variant.sku));
+  }
+  composeSingle(body) {
+    const generator = new Faker({
+      seed: 42,
+      locale: [en, base]
+    });
+    const result = {
+      identifier: {
+        key: body
+      },
+      name: generator.commerce.productName(),
+      slug: body,
+      brand: "",
+      longDescription: "",
+      mainVariant: {
+        barcode: "",
+        ean: "",
+        gtin: "",
+        identifier: {
+          sku: ""
+        },
+        images: [],
+        name: "",
+        options: [],
+        upc: ""
+      },
+      description: generator.commerce.productDescription(),
+      manufacturer: "",
+      options: [],
+      parentCategories: [],
+      published: true,
+      sharedAttributes: [],
+      variants: []
+    };
+    return this.factory.parseProduct(this.context, result);
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: ProductQueryByIdSchema,
+    outputSchema: ProductSchema,
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: true
+  })
+], FakeProductCapability.prototype, "getById", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProductQueryBySlugSchema,
+    outputSchema: ProductSchema
+  })
+], FakeProductCapability.prototype, "getBySlug", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProductQueryBySKUSchema,
+    outputSchema: ProductSchema
+  })
+], FakeProductCapability.prototype, "getBySKU", 1);
+export {
+  FakeProductCapability
+};

package/capabilities/profile.capability.js

@@ -0,0 +1,130 @@
+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 {
+  AddressSchema,
+  ProfileMutationAddShippingAddressSchema,
+  ProfileMutationMakeShippingAddressDefaultSchema,
+  ProfileMutationRemoveShippingAddressSchema,
+  ProfileMutationSetBillingAddressSchema,
+  ProfileMutationUpdateSchema,
+  ProfileMutationUpdateShippingAddressSchema,
+  ProfileCapability,
+  ProfileQueryByIdSchema,
+  ProfileSchema,
+  Reactionary,
+  success
+} from "@reactionary/core";
+import { base, en, Faker } from "@faker-js/faker";
+class FakeProfileCapability extends ProfileCapability {
+  config;
+  factory;
+  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) {
+    return success(this.composeProfile(payload.identifier));
+  }
+  async update(payload) {
+    return success(this.composeProfile(payload.identifier));
+  }
+  async addShippingAddress(payload) {
+    return success(this.composeProfile(payload.identifier));
+  }
+  async updateShippingAddress(payload) {
+    return success(this.composeProfile(payload.identifier));
+  }
+  async removeShippingAddress(payload) {
+    return success(this.composeProfile(payload.identifier));
+  }
+  async makeShippingAddressDefault(payload) {
+    return success(this.composeProfile(payload.identifier));
+  }
+  async setBillingAddress(payload) {
+    return success(this.composeProfile(payload.identifier));
+  }
+  composeProfile(identifier) {
+    const baseProfile = {
+      identifier,
+      email: this.generator.internet.email(),
+      phone: this.generator.phone.number(),
+      emailVerified: true,
+      phoneVerified: true,
+      createdAt: this.generator.date.past().toISOString(),
+      updatedAt: this.generator.date.recent().toISOString(),
+      billingAddress: this.createEmptyAddress(),
+      shippingAddress: this.createEmptyAddress(),
+      alternateShippingAddresses: []
+    };
+    return this.factory.parseProfile(this.context, baseProfile);
+  }
+  createEmptyAddress() {
+    return AddressSchema.parse({
+      identifier: {
+        nickName: this.generator.person.firstName().toLowerCase()
+      },
+      firstName: this.generator.person.firstName(),
+      lastName: this.generator.person.lastName(),
+      streetAddress: this.generator.location.street(),
+      streetNumber: this.generator.location.buildingNumber(),
+      city: this.generator.location.city(),
+      region: this.generator.location.state(),
+      postalCode: this.generator.location.zipCode(),
+      countryCode: this.generator.location.countryCode("alpha-2")
+    });
+  }
+}
+__decorateClass([
+  Reactionary({ inputSchema: ProfileQueryByIdSchema, outputSchema: ProfileSchema })
+], FakeProfileCapability.prototype, "getById", 1);
+__decorateClass([
+  Reactionary({ inputSchema: ProfileMutationUpdateSchema, outputSchema: ProfileSchema })
+], FakeProfileCapability.prototype, "update", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProfileMutationAddShippingAddressSchema,
+    outputSchema: ProfileSchema
+  })
+], FakeProfileCapability.prototype, "addShippingAddress", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProfileMutationUpdateShippingAddressSchema,
+    outputSchema: ProfileSchema
+  })
+], FakeProfileCapability.prototype, "updateShippingAddress", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProfileMutationRemoveShippingAddressSchema,
+    outputSchema: ProfileSchema
+  })
+], FakeProfileCapability.prototype, "removeShippingAddress", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProfileMutationMakeShippingAddressDefaultSchema,
+    outputSchema: ProfileSchema
+  })
+], FakeProfileCapability.prototype, "makeShippingAddressDefault", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProfileMutationSetBillingAddressSchema,
+    outputSchema: ProfileSchema
+  })
+], FakeProfileCapability.prototype, "setBillingAddress", 1);
+export {
+  FakeProfileCapability
+};

package/capabilities/store.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 {
+  Reactionary,
+  StoreCapability,
+  StoreQueryByProximitySchema,
+  StoreSchema,
+  success
+} from "@reactionary/core";
+import * as z from "zod";
+import { base, en, Faker } from "@faker-js/faker";
+class FakeStoreCapability extends StoreCapability {
+  config;
+  factory;
+  constructor(config, cache, context, factory) {
+    super(cache, context);
+    this.config = config;
+    this.factory = factory;
+  }
+  async queryByProximity(payload) {
+    const generator = new Faker({
+      seed: 42,
+      locale: [en, base]
+    });
+    const results = [];
+    for (let i = 0; i < payload.limit; i++) {
+      results.push(
+        this.factory.parseStore(this.context, {
+          identifier: {
+            key: `${i}`
+          },
+          fulfillmentCenter: {
+            key: `${i}`
+          },
+          name: generator.company.name()
+        })
+      );
+    }
+    return success(results);
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: StoreQueryByProximitySchema,
+    outputSchema: z.array(StoreSchema)
+  })
+], FakeStoreCapability.prototype, "queryByProximity", 1);
+export {
+  FakeStoreCapability
+};

package/core/initialize.js

@@ -0,0 +1,235 @@
+import {
+  CartIdentifierSchema as CoreCartIdentifierSchema,
+  CartSchema as CoreCartSchema,
+  CategoryPaginatedResultSchema as CoreCategoryPaginatedResultSchema,
+  CategorySchema as CoreCategorySchema,
+  CheckoutSchema as CoreCheckoutSchema,
+  IdentitySchema as CoreIdentitySchema,
+  InventorySchema as CoreInventorySchema,
+  OrderSchema as CoreOrderSchema,
+  OrderSearchResultSchema as CoreOrderSearchResultSchema,
+  PaymentMethodSchema as CorePaymentMethodSchema,
+  PriceSchema as CorePriceSchema,
+  ProductAssociationSchema as CoreProductAssociationSchema,
+  ProductRatingSummarySchema as CoreProductRatingSummarySchema,
+  ProductReviewPaginatedResultSchema as CoreProductReviewPaginatedResultSchema,
+  ProductReviewSchema as CoreProductReviewSchema,
+  ProductSchema as CoreProductSchema,
+  ProductSearchResultSchema as CoreProductSearchResultSchema,
+  ProfileSchema as CoreProfileSchema,
+  ShippingMethodSchema as CoreShippingMethodSchema,
+  StoreSchema as CoreStoreSchema
+} from "@reactionary/core";
+import { FakeProductCapability } from "../capabilities/product.capability.js";
+import { FakeProductSearchCapability } from "../capabilities/product-search.capability.js";
+import { FakeCapabilitiesSchema } from "../schema/capabilities.schema.js";
+import { FakeCategoryCapability } from "../capabilities/category.capability.js";
+import {
+  FakeCartCapability,
+  FakeIdentityCapability,
+  FakeInventoryCapability,
+  FakePriceCapability,
+  FakeStoreCapability
+} from "../capabilities/index.js";
+import { FakeCheckoutCapability } from "../capabilities/checkout.capability.js";
+import { FakeOrderSearchCapability } from "../capabilities/order-search.capability.js";
+import { FakeOrderCapability } from "../capabilities/order.capability.js";
+import { FakeProfileCapability } from "../capabilities/profile.capability.js";
+import { FakeProductReviewsCapability } from "../capabilities/product-reviews.capability.js";
+import { FakeProductAssociationsCapability } from "../capabilities/product-associations.capability.js";
+import {
+  FakeCartFactory,
+  FakeCategoryFactory,
+  FakeCheckoutFactory,
+  FakeIdentityFactory,
+  FakeInventoryFactory,
+  FakeOrderFactory,
+  FakeOrderSearchFactory,
+  FakePriceFactory,
+  FakeProductAssociationsFactory,
+  FakeProductFactory,
+  FakeProductReviewsFactory,
+  FakeProductSearchFactory,
+  FakeProfileFactory,
+  FakeStoreFactory
+} from "../factories/index.js";
+import {
+  resolveCapabilityWithFactory
+} from "./initialize.types.js";
+function withFakeCapabilities(configuration, capabilities) {
+  return (cache, context) => {
+    const client = {};
+    const caps = FakeCapabilitiesSchema.parse(capabilities);
+    const buildCapabilityArgs = (factory) => ({
+      cache,
+      context,
+      config: configuration,
+      factory
+    });
+    if (caps.product?.enabled) {
+      client.product = resolveCapabilityWithFactory(
+        capabilities.product,
+        {
+          factory: new FakeProductFactory(CoreProductSchema),
+          capability: (args) => new FakeProductCapability(args.config, args.cache, args.context, args.factory)
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.productSearch?.enabled) {
+      client.productSearch = resolveCapabilityWithFactory(
+        capabilities.productSearch,
+        {
+          factory: new FakeProductSearchFactory(CoreProductSearchResultSchema),
+          capability: (args) => new FakeProductSearchCapability(args.config, args.cache, args.context, args.factory)
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.category?.enabled) {
+      client.category = resolveCapabilityWithFactory(
+        capabilities.category,
+        {
+          factory: new FakeCategoryFactory(
+            CoreCategorySchema,
+            CoreCategoryPaginatedResultSchema
+          ),
+          capability: (args) => new FakeCategoryCapability(args.config, args.cache, args.context, args.factory)
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.cart?.enabled) {
+      client.cart = resolveCapabilityWithFactory(
+        capabilities.cart,
+        {
+          factory: new FakeCartFactory(CoreCartSchema, CoreCartIdentifierSchema),
+          capability: (args) => new FakeCartCapability(args.config, args.cache, args.context, args.factory)
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.inventory?.enabled) {
+      client.inventory = resolveCapabilityWithFactory(
+        capabilities.inventory,
+        {
+          factory: new FakeInventoryFactory(CoreInventorySchema),
+          capability: (args) => new FakeInventoryCapability(args.config, args.cache, args.context, args.factory)
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.store?.enabled) {
+      client.store = resolveCapabilityWithFactory(
+        capabilities.store,
+        {
+          factory: new FakeStoreFactory(CoreStoreSchema),
+          capability: (args) => new FakeStoreCapability(args.config, args.cache, args.context, args.factory)
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.price?.enabled) {
+      client.price = resolveCapabilityWithFactory(
+        capabilities.price,
+        {
+          factory: new FakePriceFactory(CorePriceSchema),
+          capability: (args) => new FakePriceCapability(args.config, args.cache, args.context, args.factory)
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.identity?.enabled) {
+      client.identity = resolveCapabilityWithFactory(
+        capabilities.identity,
+        {
+          factory: new FakeIdentityFactory(CoreIdentitySchema),
+          capability: (args) => new FakeIdentityCapability(args.config, args.cache, args.context, args.factory)
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.checkout?.enabled) {
+      client.checkout = resolveCapabilityWithFactory(
+        capabilities.checkout,
+        {
+          factory: new FakeCheckoutFactory(
+            CoreCheckoutSchema,
+            CoreShippingMethodSchema,
+            CorePaymentMethodSchema
+          ),
+          capability: (args) => new FakeCheckoutCapability(args.config, args.cache, args.context, args.factory)
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.orderSearch?.enabled) {
+      client.orderSearch = resolveCapabilityWithFactory(
+        capabilities.orderSearch,
+        {
+          factory: new FakeOrderSearchFactory(CoreOrderSearchResultSchema),
+          capability: (args) => new FakeOrderSearchCapability(args.config, args.cache, args.context, args.factory)
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.order?.enabled) {
+      client.order = resolveCapabilityWithFactory(
+        capabilities.order,
+        {
+          factory: new FakeOrderFactory(CoreOrderSchema),
+          capability: (args) => new FakeOrderCapability(args.config, args.cache, args.context, args.factory)
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.profile?.enabled) {
+      client.profile = resolveCapabilityWithFactory(
+        capabilities.profile,
+        {
+          factory: new FakeProfileFactory(CoreProfileSchema),
+          capability: (args) => new FakeProfileCapability(args.config, args.cache, args.context, args.factory)
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.productReviews?.enabled) {
+      client.productReviews = resolveCapabilityWithFactory(
+        capabilities.productReviews,
+        {
+          factory: new FakeProductReviewsFactory(
+            CoreProductRatingSummarySchema,
+            CoreProductReviewSchema,
+            CoreProductReviewPaginatedResultSchema
+          ),
+          capability: (args) => new FakeProductReviewsCapability(
+            args.config,
+            args.cache,
+            args.context,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.productAssociations?.enabled) {
+      client.productAssociations = resolveCapabilityWithFactory(
+        capabilities.productAssociations,
+        {
+          factory: new FakeProductAssociationsFactory(CoreProductAssociationSchema),
+          capability: (args) => new FakeProductAssociationsCapability(
+            args.config,
+            args.cache,
+            args.context,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
+    return client;
+  };
+}
+export {
+  withFakeCapabilities
+};

package/core/initialize.types.js

@@ -0,0 +1,8 @@
+function resolveCapabilityWithFactory(capability, defaults, buildCapabilityArgs) {
+  const factory = capability?.factory ?? defaults.factory;
+  const capabilityFactory = capability?.capability ?? defaults.capability;
+  return capabilityFactory(buildCapabilityArgs(factory));
+}
+export {
+  resolveCapabilityWithFactory
+};

package/factories/cart/cart.factory.js

@@ -0,0 +1,17 @@
+class FakeCartFactory {
+  cartSchema;
+  cartIdentifierSchema;
+  constructor(cartSchema, cartIdentifierSchema) {
+    this.cartSchema = cartSchema;
+    this.cartIdentifierSchema = cartIdentifierSchema;
+  }
+  parseCart(_context, data) {
+    return this.cartSchema.parse(data);
+  }
+  parseCartIdentifier(_context, data) {
+    return this.cartIdentifierSchema.parse(data);
+  }
+}
+export {
+  FakeCartFactory
+};