@reactionary/provider-fake 0.3.18 → 0.6.2

package/core/initialize.js

@@ -1,5 +1,28 @@
+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 { FakeProductProvider } from "../providers/product.provider.js";
 import { FakeSearchProvider } from "../providers/product-search.provider.js";
+import { FakeCapabilitiesSchema } from "../schema/capabilities.schema.js";
 import { FakeCategoryProvider } from "../providers/category.provider.js";
 import {
   FakeCartProvider,
@@ -14,62 +37,195 @@ import { FakeOrderProvider } from "../providers/order.provider.js";
 import { FakeProfileProvider } from "../providers/profile.provider.js";
 import { FakeProductReviewsProvider } from "../providers/product-reviews.provider.js";
 import { FakeProductAssociationsProvider } from "../providers/product-associations.provider.js";
+import {
+  FakeCartFactory,
+  FakeCategoryFactory,
+  FakeCheckoutFactory,
+  FakeIdentityFactory,
+  FakeInventoryFactory,
+  FakeOrderFactory,
+  FakeOrderSearchFactory,
+  FakePriceFactory,
+  FakeProductAssociationsFactory,
+  FakeProductFactory,
+  FakeProductReviewsFactory,
+  FakeProductSearchFactory,
+  FakeProfileFactory,
+  FakeStoreFactory
+} from "../factories/index.js";
+import {
+  resolveCapabilityProvider
+} from "./initialize.types.js";
 function withFakeCapabilities(configuration, capabilities) {
   return (cache, context) => {
     const client = {};
-    if (capabilities.product) {
-      client.product = new FakeProductProvider(configuration, cache, context);
+    const caps = FakeCapabilitiesSchema.parse(capabilities);
+    const buildProviderArgs = (factory) => ({
+      cache,
+      context,
+      config: configuration,
+      factory
+    });
+    if (caps.product?.enabled) {
+      client.product = resolveCapabilityProvider(
+        capabilities.product,
+        {
+          factory: new FakeProductFactory(CoreProductSchema),
+          provider: (args) => new FakeProductProvider(args.config, args.cache, args.context, args.factory)
+        },
+        buildProviderArgs
+      );
     }
-    if (capabilities.productSearch) {
-      client.productSearch = new FakeSearchProvider(
-        configuration,
-        cache,
-        context
+    if (caps.productSearch?.enabled) {
+      client.productSearch = resolveCapabilityProvider(
+        capabilities.productSearch,
+        {
+          factory: new FakeProductSearchFactory(CoreProductSearchResultSchema),
+          provider: (args) => new FakeSearchProvider(args.config, args.cache, args.context, args.factory)
+        },
+        buildProviderArgs
       );
     }
-    if (capabilities.category) {
-      client.category = new FakeCategoryProvider(configuration, cache, context);
+    if (caps.category?.enabled) {
+      client.category = resolveCapabilityProvider(
+        capabilities.category,
+        {
+          factory: new FakeCategoryFactory(
+            CoreCategorySchema,
+            CoreCategoryPaginatedResultSchema
+          ),
+          provider: (args) => new FakeCategoryProvider(args.config, args.cache, args.context, args.factory)
+        },
+        buildProviderArgs
+      );
     }
-    if (capabilities.cart) {
-      client.cart = new FakeCartProvider(configuration, cache, context);
+    if (caps.cart?.enabled) {
+      client.cart = resolveCapabilityProvider(
+        capabilities.cart,
+        {
+          factory: new FakeCartFactory(CoreCartSchema, CoreCartIdentifierSchema),
+          provider: (args) => new FakeCartProvider(args.config, args.cache, args.context, args.factory)
+        },
+        buildProviderArgs
+      );
     }
-    if (capabilities.inventory) {
-      client.inventory = new FakeInventoryProvider(
-        configuration,
-        cache,
-        context
+    if (caps.inventory?.enabled) {
+      client.inventory = resolveCapabilityProvider(
+        capabilities.inventory,
+        {
+          factory: new FakeInventoryFactory(CoreInventorySchema),
+          provider: (args) => new FakeInventoryProvider(args.config, args.cache, args.context, args.factory)
+        },
+        buildProviderArgs
       );
     }
-    if (capabilities.store) {
-      client.store = new FakeStoreProvider(configuration, cache, context);
+    if (caps.store?.enabled) {
+      client.store = resolveCapabilityProvider(
+        capabilities.store,
+        {
+          factory: new FakeStoreFactory(CoreStoreSchema),
+          provider: (args) => new FakeStoreProvider(args.config, args.cache, args.context, args.factory)
+        },
+        buildProviderArgs
+      );
     }
-    if (capabilities.price) {
-      client.price = new FakePriceProvider(configuration, cache, context);
+    if (caps.price?.enabled) {
+      client.price = resolveCapabilityProvider(
+        capabilities.price,
+        {
+          factory: new FakePriceFactory(CorePriceSchema),
+          provider: (args) => new FakePriceProvider(args.config, args.cache, args.context, args.factory)
+        },
+        buildProviderArgs
+      );
     }
-    if (capabilities.identity) {
-      client.identity = new FakeIdentityProvider(configuration, cache, context);
+    if (caps.identity?.enabled) {
+      client.identity = resolveCapabilityProvider(
+        capabilities.identity,
+        {
+          factory: new FakeIdentityFactory(CoreIdentitySchema),
+          provider: (args) => new FakeIdentityProvider(args.config, args.cache, args.context, args.factory)
+        },
+        buildProviderArgs
+      );
     }
-    if (capabilities.checkout) {
-      client.checkout = new FakeCheckoutProvider(configuration, cache, context);
+    if (caps.checkout?.enabled) {
+      client.checkout = resolveCapabilityProvider(
+        capabilities.checkout,
+        {
+          factory: new FakeCheckoutFactory(
+            CoreCheckoutSchema,
+            CoreShippingMethodSchema,
+            CorePaymentMethodSchema
+          ),
+          provider: (args) => new FakeCheckoutProvider(args.config, args.cache, args.context, args.factory)
+        },
+        buildProviderArgs
+      );
     }
-    if (capabilities.orderSearch) {
-      client.orderSearch = new FakeOrderSearchProvider(
-        configuration,
-        cache,
-        context
+    if (caps.orderSearch?.enabled) {
+      client.orderSearch = resolveCapabilityProvider(
+        capabilities.orderSearch,
+        {
+          factory: new FakeOrderSearchFactory(CoreOrderSearchResultSchema),
+          provider: (args) => new FakeOrderSearchProvider(args.config, args.cache, args.context, args.factory)
+        },
+        buildProviderArgs
       );
     }
-    if (capabilities.order) {
-      client.order = new FakeOrderProvider(configuration, cache, context);
+    if (caps.order?.enabled) {
+      client.order = resolveCapabilityProvider(
+        capabilities.order,
+        {
+          factory: new FakeOrderFactory(CoreOrderSchema),
+          provider: (args) => new FakeOrderProvider(args.config, args.cache, args.context, args.factory)
+        },
+        buildProviderArgs
+      );
     }
-    if (capabilities.profile) {
-      client.profile = new FakeProfileProvider(configuration, cache, context);
+    if (caps.profile?.enabled) {
+      client.profile = resolveCapabilityProvider(
+        capabilities.profile,
+        {
+          factory: new FakeProfileFactory(CoreProfileSchema),
+          provider: (args) => new FakeProfileProvider(args.config, args.cache, args.context, args.factory)
+        },
+        buildProviderArgs
+      );
     }
-    if (capabilities.productReviews) {
-      client.productReviews = new FakeProductReviewsProvider(configuration, cache, context);
+    if (caps.productReviews?.enabled) {
+      client.productReviews = resolveCapabilityProvider(
+        capabilities.productReviews,
+        {
+          factory: new FakeProductReviewsFactory(
+            CoreProductRatingSummarySchema,
+            CoreProductReviewSchema,
+            CoreProductReviewPaginatedResultSchema
+          ),
+          provider: (args) => new FakeProductReviewsProvider(
+            args.config,
+            args.cache,
+            args.context,
+            args.factory
+          )
+        },
+        buildProviderArgs
+      );
     }
-    if (capabilities.productAssociations) {
-      client.productAssociations = new FakeProductAssociationsProvider(configuration, cache, context);
+    if (caps.productAssociations?.enabled) {
+      client.productAssociations = resolveCapabilityProvider(
+        capabilities.productAssociations,
+        {
+          factory: new FakeProductAssociationsFactory(CoreProductAssociationSchema),
+          provider: (args) => new FakeProductAssociationsProvider(
+            args.config,
+            args.cache,
+            args.context,
+            args.factory
+          )
+        },
+        buildProviderArgs
+      );
     }
     return client;
   };

package/core/initialize.types.js

@@ -0,0 +1,8 @@
+function resolveCapabilityProvider(capability, defaults, buildProviderArgs) {
+  const factory = capability?.factory ?? defaults.factory;
+  const provider = capability?.provider ?? defaults.provider;
+  return provider(buildProviderArgs(factory));
+}
+export {
+  resolveCapabilityProvider
+};

package/factories/cart/cart.factory.js

@@ -0,0 +1,15 @@
+class FakeCartFactory {
+  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
+};

package/factories/category/category.factory.js

@@ -0,0 +1,15 @@
+class FakeCategoryFactory {
+  constructor(categorySchema, categoryPaginatedResultSchema) {
+    this.categorySchema = categorySchema;
+    this.categoryPaginatedResultSchema = categoryPaginatedResultSchema;
+  }
+  parseCategory(_context, data) {
+    return this.categorySchema.parse(data);
+  }
+  parseCategoryPaginatedResult(_context, data) {
+    return this.categoryPaginatedResultSchema.parse(data);
+  }
+}
+export {
+  FakeCategoryFactory
+};

package/factories/checkout/checkout.factory.js

@@ -0,0 +1,19 @@
+class FakeCheckoutFactory {
+  constructor(checkoutSchema, shippingMethodSchema, paymentMethodSchema) {
+    this.checkoutSchema = checkoutSchema;
+    this.shippingMethodSchema = shippingMethodSchema;
+    this.paymentMethodSchema = paymentMethodSchema;
+  }
+  parseCheckout(_context, data) {
+    return this.checkoutSchema.parse(data);
+  }
+  parseShippingMethod(_context, data) {
+    return this.shippingMethodSchema.parse(data);
+  }
+  parsePaymentMethod(_context, data) {
+    return this.paymentMethodSchema.parse(data);
+  }
+}
+export {
+  FakeCheckoutFactory
+};

package/factories/identity/identity.factory.js

@@ -0,0 +1,11 @@
+class FakeIdentityFactory {
+  constructor(identitySchema) {
+    this.identitySchema = identitySchema;
+  }
+  parseIdentity(_context, data) {
+    return this.identitySchema.parse(data);
+  }
+}
+export {
+  FakeIdentityFactory
+};

package/factories/index.js

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

package/factories/inventory/inventory.factory.js

@@ -0,0 +1,11 @@
+class FakeInventoryFactory {
+  constructor(inventorySchema) {
+    this.inventorySchema = inventorySchema;
+  }
+  parseInventory(_context, data) {
+    return this.inventorySchema.parse(data);
+  }
+}
+export {
+  FakeInventoryFactory
+};

package/factories/order/order.factory.js

@@ -0,0 +1,11 @@
+class FakeOrderFactory {
+  constructor(orderSchema) {
+    this.orderSchema = orderSchema;
+  }
+  parseOrder(_context, data) {
+    return this.orderSchema.parse(data);
+  }
+}
+export {
+  FakeOrderFactory
+};

package/factories/order-search/order-search.factory.js

@@ -0,0 +1,11 @@
+class FakeOrderSearchFactory {
+  constructor(orderSearchResultSchema) {
+    this.orderSearchResultSchema = orderSearchResultSchema;
+  }
+  parseOrderSearchResult(_context, data, _query) {
+    return this.orderSearchResultSchema.parse(data);
+  }
+}
+export {
+  FakeOrderSearchFactory
+};

package/factories/price/price.factory.js

@@ -0,0 +1,11 @@
+class FakePriceFactory {
+  constructor(priceSchema) {
+    this.priceSchema = priceSchema;
+  }
+  parsePrice(_context, data, _options) {
+    return this.priceSchema.parse(data);
+  }
+}
+export {
+  FakePriceFactory
+};

package/factories/product/product.factory.js

@@ -0,0 +1,11 @@
+class FakeProductFactory {
+  constructor(productSchema) {
+    this.productSchema = productSchema;
+  }
+  parseProduct(_context, data) {
+    return this.productSchema.parse(data);
+  }
+}
+export {
+  FakeProductFactory
+};

package/factories/product-associations/product-associations.factory.js

@@ -0,0 +1,11 @@
+class FakeProductAssociationsFactory {
+  constructor(productAssociationSchema) {
+    this.productAssociationSchema = productAssociationSchema;
+  }
+  parseAssociation(_context, data) {
+    return this.productAssociationSchema.parse(data);
+  }
+}
+export {
+  FakeProductAssociationsFactory
+};

package/factories/product-reviews/product-reviews.factory.js

@@ -0,0 +1,19 @@
+class FakeProductReviewsFactory {
+  constructor(ratingSummarySchema, reviewSchema, reviewPaginatedSchema) {
+    this.ratingSummarySchema = ratingSummarySchema;
+    this.reviewSchema = reviewSchema;
+    this.reviewPaginatedSchema = reviewPaginatedSchema;
+  }
+  parseRatingSummary(_context, data) {
+    return this.ratingSummarySchema.parse(data);
+  }
+  parseReview(_context, data) {
+    return this.reviewSchema.parse(data);
+  }
+  parseReviewPaginatedResult(_context, data) {
+    return this.reviewPaginatedSchema.parse(data);
+  }
+}
+export {
+  FakeProductReviewsFactory
+};

package/factories/product-search/product-search.factory.js

@@ -0,0 +1,11 @@
+class FakeProductSearchFactory {
+  constructor(productSearchResultSchema) {
+    this.productSearchResultSchema = productSearchResultSchema;
+  }
+  parseSearchResult(_context, data, _query) {
+    return this.productSearchResultSchema.parse(data);
+  }
+}
+export {
+  FakeProductSearchFactory
+};

package/factories/profile/profile.factory.js

@@ -0,0 +1,11 @@
+class FakeProfileFactory {
+  constructor(profileSchema) {
+    this.profileSchema = profileSchema;
+  }
+  parseProfile(_context, data) {
+    return this.profileSchema.parse(data);
+  }
+}
+export {
+  FakeProfileFactory
+};

package/factories/store/store.factory.js

@@ -0,0 +1,11 @@
+class FakeStoreFactory {
+  constructor(storeSchema) {
+    this.storeSchema = storeSchema;
+  }
+  parseStore(_context, data) {
+    return this.storeSchema.parse(data);
+  }
+}
+export {
+  FakeStoreFactory
+};

package/index.js

@@ -1,4 +1,6 @@
 export * from "./core/initialize.js";
+export * from "./core/initialize.types.js";
 export * from "./providers/index.js";
+export * from "./factories/index.js";
 export * from "./schema/capabilities.schema.js";
 export * from "./schema/configuration.schema.js";

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@reactionary/provider-fake",
-  "version": "0.3.18",
+  "version": "0.6.2",
   "main": "index.js",
   "types": "src/index.d.ts",
   "dependencies": {
-    "@reactionary/core": "0.3.18",
+    "@reactionary/core": "0.6.2",
     "zod": "4.1.9",
     "@faker-js/faker": "^9.8.0"
   },

package/providers/cart.provider.js

@@ -28,7 +28,7 @@ import {
 } from "@reactionary/core";
 import { Faker, en, base } from "@faker-js/faker";
 class FakeCartProvider extends CartProvider {
-  constructor(config, cache, context) {
+  constructor(config, cache, context, factory) {
     super(cache, context);
     this.carts = /* @__PURE__ */ new Map();
     this.generator = new Faker({
@@ -36,6 +36,7 @@ class FakeCartProvider extends CartProvider {
       seed: config.seeds.product
     });
     this.config = config;
+    this.factory = factory;
   }
   async getById(payload) {
     const cartId = payload.cart.key;
@@ -54,7 +55,7 @@ class FakeCartProvider extends CartProvider {
     if (!cart) {
       throw new Error(`Cart with id ${cartId} not found`);
     }
-    return success(cart);
+    return success(this.factory.parseCart(this.context, cart));
   }
   async add(payload) {
     const cartId = payload?.cart?.key || `cart-${this.generator.string.uuid()}`;
@@ -99,7 +100,7 @@ class FakeCartProvider extends CartProvider {
       });
     }
     this.recalculateCart(cart);
-    return success(cart);
+    return success(this.factory.parseCart(this.context, cart));
   }
   async remove(payload) {
     const cartId = payload.cart.key || `cart-${this.generator.string.uuid()}`;
@@ -108,7 +109,7 @@ class FakeCartProvider extends CartProvider {
       (item) => item.identifier.key !== payload.item.key
     );
     this.recalculateCart(cart);
-    return success(cart);
+    return success(this.factory.parseCart(this.context, cart));
   }
   async changeQuantity(payload) {
     const cartId = payload.cart.key || `cart-${this.generator.string.uuid()}`;
@@ -117,13 +118,13 @@ class FakeCartProvider extends CartProvider {
       (item2) => item2.identifier.key === payload.item.key
     );
     if (payload.quantity < 1) {
-      return success(cart);
+      return success(this.factory.parseCart(this.context, cart));
     }
     if (item) {
       item.quantity = payload.quantity;
     }
     this.recalculateCart(cart);
-    return success(cart);
+    return success(this.factory.parseCart(this.context, cart));
   }
   getActiveCartId() {
     throw new Error("Method not implemented.");