@reactionary/provider-fake 0.0.81 → 0.0.83

package/core/initialize.js

@@ -22,7 +22,6 @@ function withFakeCapabilities(configuration, capabilities) {
     if (capabilities.product) {
       client.product = new FakeProductProvider(
         configuration,
-        ProductSchema,
         cache,
         context
       );
@@ -30,7 +29,6 @@ function withFakeCapabilities(configuration, capabilities) {
     if (capabilities.productSearch) {
       client.productSearch = new FakeSearchProvider(
         configuration,
-        ProductSearchResultItemSchema,
         cache,
         context
       );
@@ -38,27 +36,25 @@ function withFakeCapabilities(configuration, capabilities) {
     if (capabilities.category) {
       client.category = new FakeCategoryProvider(
         configuration,
-        CategorySchema,
         cache,
         context
       );
     }
     if (capabilities.cart) {
-      client.cart = new FakeCartProvider(configuration, CartSchema, cache, context);
+      client.cart = new FakeCartProvider(configuration, cache, context);
     }
     if (capabilities.inventory) {
       client.inventory = new FakeInventoryProvider(
         configuration,
-        InventorySchema,
         cache,
         context
       );
     }
     if (capabilities.store) {
-      client.store = new FakeStoreProvider(configuration, StoreSchema, cache, context);
+      client.store = new FakeStoreProvider(configuration, cache, context);
     }
     if (capabilities.price) {
-      client.price = new FakePriceProvider(configuration, PriceSchema, cache, context);
+      client.price = new FakePriceProvider(configuration, cache, context);
     }
     return client;
   };

package/package.json

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

package/providers/analytics.provider.js

@@ -2,8 +2,8 @@ import {
   AnalyticsProvider
 } from "@reactionary/core";
 class FakeAnalyticsProvider extends AnalyticsProvider {
-  constructor(config, schema, cache, context) {
-    super(schema, cache, context);
+  constructor(config, cache, context) {
+    super(cache, context);
     this.config = config;
   }
 }

package/providers/cart.provider.js

@@ -1,10 +1,32 @@
+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 {
-  CartProvider
+  CartIdentifierSchema,
+  CartMutationApplyCouponSchema,
+  CartMutationChangeCurrencySchema,
+  CartMutationDeleteCartSchema,
+  CartMutationItemAddSchema,
+  CartMutationItemQuantityChangeSchema,
+  CartMutationItemRemoveSchema,
+  CartMutationRemoveCouponSchema,
+  CartProvider,
+  CartQueryByIdSchema,
+  CartSchema,
+  Reactionary
 } from "@reactionary/core";
 import { Faker, en, base } from "@faker-js/faker";
 class FakeCartProvider extends CartProvider {
-  constructor(config, schema, cache, context) {
-    super(schema, cache, context);
+  constructor(config, cache, context) {
+    super(cache, context);
     this.carts = /* @__PURE__ */ new Map();
     this.generator = new Faker({
       locale: [en, base],
@@ -15,27 +37,12 @@ class FakeCartProvider extends CartProvider {
   async getById(payload) {
     const cartId = payload.cart.key;
     if (payload.cart.key === "") {
-      const result = this.newModel();
-      result.meta = {
-        cache: { hit: false, key: "empty" },
-        placeholder: true
-      };
-      return this.assert(result);
+      return this.createEmptyCart();
     }
     if (!this.carts.has(cartId)) {
-      const model = this.newModel();
-      Object.assign(model, {
-        identifier: { key: cartId },
-        items: [],
-        meta: {
-          cache: {
-            hit: false,
-            key: cartId
-          },
-          placeholder: false
-        }
-      });
-      this.carts.set(cartId, this.assert(model));
+      const cart2 = this.createEmptyCart();
+      cart2.identifier.key = cartId;
+      this.carts.set(cartId, cart2);
     }
     const cart = this.carts.get(cartId);
     if (!cart) {
@@ -82,7 +89,7 @@ class FakeCartProvider extends CartProvider {
       });
     }
     this.recalculateCart(cart);
-    return this.assert(cart);
+    return cart;
   }
   async remove(payload) {
     const cartId = payload.cart.key || `cart-${this.generator.string.uuid()}`;
@@ -91,7 +98,7 @@ class FakeCartProvider extends CartProvider {
       (item) => item.identifier.key !== payload.item.key
     );
     this.recalculateCart(cart);
-    return this.assert(cart);
+    return cart;
   }
   async changeQuantity(payload) {
     const cartId = payload.cart.key || `cart-${this.generator.string.uuid()}`;
@@ -106,7 +113,7 @@ class FakeCartProvider extends CartProvider {
       item.quantity = payload.quantity;
     }
     this.recalculateCart(cart);
-    return this.assert(cart);
+    return cart;
   }
   getActiveCartId() {
     throw new Error("Method not implemented.");
@@ -137,6 +144,59 @@ class FakeCartProvider extends CartProvider {
     };
   }
 }
+__decorateClass([
+  Reactionary({
+    inputSchema: CartQueryByIdSchema,
+    outputSchema: CartSchema
+  })
+], FakeCartProvider.prototype, "getById", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationItemAddSchema,
+    outputSchema: CartSchema
+  })
+], FakeCartProvider.prototype, "add", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationItemRemoveSchema,
+    outputSchema: CartSchema
+  })
+], FakeCartProvider.prototype, "remove", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationItemQuantityChangeSchema,
+    outputSchema: CartSchema
+  })
+], FakeCartProvider.prototype, "changeQuantity", 1);
+__decorateClass([
+  Reactionary({
+    outputSchema: CartIdentifierSchema
+  })
+], FakeCartProvider.prototype, "getActiveCartId", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationDeleteCartSchema,
+    outputSchema: CartSchema
+  })
+], FakeCartProvider.prototype, "deleteCart", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationApplyCouponSchema,
+    outputSchema: CartSchema
+  })
+], FakeCartProvider.prototype, "applyCouponCode", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationRemoveCouponSchema,
+    outputSchema: CartSchema
+  })
+], FakeCartProvider.prototype, "removeCouponCode", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationChangeCurrencySchema,
+    outputSchema: CartSchema
+  })
+], FakeCartProvider.prototype, "changeCurrency", 1);
 export {
   FakeCartProvider
 };

package/providers/category.provider.js

@@ -9,11 +9,12 @@ var __decorateClass = (decorators, target, key, kind) => {
     __defProp(target, key, result);
   return result;
 };
-import { CategoryProvider, Reactionary } from "@reactionary/core";
+import { CategoryPaginatedResultSchema, CategoryProvider, CategoryQueryByIdSchema, CategoryQueryBySlugSchema, CategoryQueryForBreadcrumbSchema, CategoryQueryForChildCategoriesSchema, CategoryQueryForTopCategoriesSchema, CategorySchema, Reactionary } from "@reactionary/core";
+import z from "zod";
 import { Faker, en, base } from "@faker-js/faker";
 class FakeCategoryProvider extends CategoryProvider {
-  constructor(config, schema, cache, context) {
-    super(schema, cache, context);
+  constructor(config, cache, context) {
+    super(cache, context);
     this.topCategories = new Array();
     this.childCategories = /* @__PURE__ */ new Map();
     this.allCategories = /* @__PURE__ */ new Map();
@@ -48,24 +49,35 @@ class FakeCategoryProvider extends CategoryProvider {
     } else {
       name = `${parent.name}-${index}`;
     }
-    const category = this.newModel();
-    category.identifier = { key: name.toLowerCase().replace(/\s+/g, "-") };
-    category.name = name;
-    category.text = this.categoryGenerator.lorem.sentences(3);
-    category.slug = category.identifier.key + "-slug";
+    const identifier = { key: name.toLowerCase().replace(/\s+/g, "-") };
+    const text = this.categoryGenerator.lorem.sentences(3);
+    const slug = identifier.key + "-slug";
+    let parentCategory;
     if (parent) {
-      category.parentCategory = parent.identifier;
+      parentCategory = parent.identifier;
     }
-    this.allCategories.set(category.identifier.key, category);
+    const category = {
+      identifier,
+      images: [],
+      meta: {
+        cache: {
+          hit: false,
+          key: ""
+        },
+        placeholder: false
+      },
+      name,
+      slug,
+      text,
+      parentCategory
+    };
+    this.allCategories.set(identifier.key, category);
     return category;
   }
   async getById(payload) {
     const category = this.allCategories.get(payload.id.key);
     if (!category) {
-      const dummyCategory = this.newModel();
-      dummyCategory.meta.placeholder = true;
-      dummyCategory.identifier = { key: payload.id.key };
-      return dummyCategory;
+      throw new Error("This should not happen...");
     }
     return category;
   }
@@ -129,14 +141,35 @@ class FakeCategoryProvider extends CategoryProvider {
   }
 }
 __decorateClass([
-  Reactionary({})
+  Reactionary({
+    inputSchema: CategoryQueryByIdSchema,
+    outputSchema: CategorySchema
+  })
 ], FakeCategoryProvider.prototype, "getById", 1);
 __decorateClass([
-  Reactionary({})
+  Reactionary({
+    inputSchema: CategoryQueryBySlugSchema,
+    outputSchema: CategorySchema
+  })
 ], FakeCategoryProvider.prototype, "getBySlug", 1);
 __decorateClass([
-  Reactionary({})
+  Reactionary({
+    inputSchema: CategoryQueryForBreadcrumbSchema,
+    outputSchema: z.array(CategorySchema)
+  })
 ], FakeCategoryProvider.prototype, "getBreadcrumbPathToCategory", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CategoryQueryForChildCategoriesSchema,
+    outputSchema: CategoryPaginatedResultSchema
+  })
+], FakeCategoryProvider.prototype, "findChildCategories", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CategoryQueryForTopCategoriesSchema,
+    outputSchema: CategoryPaginatedResultSchema
+  })
+], FakeCategoryProvider.prototype, "findTopCategories", 1);
 export {
   FakeCategoryProvider
 };

package/providers/identity.provider.js

@@ -1,22 +1,34 @@
+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 {
-  IdentityProvider
+  IdentityProvider,
+  Reactionary,
+  IdentityMutationRegisterSchema,
+  IdentitySchema,
+  IdentityMutationLogoutSchema,
+  IdentityMutationLoginSchema,
+  IdentityQuerySelfSchema
 } from "@reactionary/core";
 import { base, en, Faker } from "@faker-js/faker";
 class FakeIdentityProvider extends IdentityProvider {
-  constructor(config, schema, cache, context) {
-    super(schema, cache, context);
+  constructor(config, cache, context) {
+    super(cache, context);
     this.currentIdentity = null;
     this.config = config;
   }
   async getSelf(_payload) {
     if (!this.currentIdentity) {
-      const model = this.newModel();
-      Object.assign(model, {
-        id: "anonymous",
+      const model = {
         type: "Anonymous",
-        issued: /* @__PURE__ */ new Date(),
-        expiry: new Date(Date.now() + 24 * 60 * 60 * 1e3),
-        // 24 hours from now
         meta: {
           cache: {
             hit: false,
@@ -24,8 +36,8 @@ class FakeIdentityProvider extends IdentityProvider {
           },
           placeholder: false
         }
-      });
-      this.currentIdentity = this.assert(model);
+      };
+      this.currentIdentity = model;
     }
     return this.currentIdentity;
   }
@@ -34,14 +46,11 @@ class FakeIdentityProvider extends IdentityProvider {
       seed: 42,
       locale: [en, base]
     });
-    const model = this.newModel();
-    Object.assign(model, {
-      id: generator.string.uuid(),
+    const model = {
       type: "Registered",
-      token: generator.string.alphanumeric(32),
-      issued: /* @__PURE__ */ new Date(),
-      expiry: new Date(Date.now() + 7 * 24 * 60 * 60 * 1e3),
-      // 7 days from now
+      id: {
+        userId: generator.string.alphanumeric(32)
+      },
       meta: {
         cache: {
           hit: false,
@@ -49,18 +58,13 @@ class FakeIdentityProvider extends IdentityProvider {
         },
         placeholder: false
       }
-    });
-    this.currentIdentity = this.assert(model);
+    };
+    this.currentIdentity = model;
     return this.currentIdentity;
   }
   async logout(_payload) {
-    const model = this.newModel();
-    Object.assign(model, {
-      id: "anonymous",
+    const model = {
       type: "Anonymous",
-      issued: /* @__PURE__ */ new Date(),
-      expiry: new Date(Date.now() + 24 * 60 * 60 * 1e3),
-      // 24 hours from now
       meta: {
         cache: {
           hit: false,
@@ -68,14 +72,38 @@ class FakeIdentityProvider extends IdentityProvider {
         },
         placeholder: false
       }
-    });
-    this.currentIdentity = this.assert(model);
+    };
+    this.currentIdentity = model;
     return this.currentIdentity;
   }
   register(payload) {
     throw new Error("Method not implemented.");
   }
 }
+__decorateClass([
+  Reactionary({
+    inputSchema: IdentityQuerySelfSchema,
+    outputSchema: IdentitySchema
+  })
+], FakeIdentityProvider.prototype, "getSelf", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: IdentityMutationLoginSchema,
+    outputSchema: IdentitySchema
+  })
+], FakeIdentityProvider.prototype, "login", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: IdentityMutationLogoutSchema,
+    outputSchema: IdentitySchema
+  })
+], FakeIdentityProvider.prototype, "logout", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: IdentityMutationRegisterSchema,
+    outputSchema: IdentitySchema
+  })
+], FakeIdentityProvider.prototype, "register", 1);
 export {
   FakeIdentityProvider
 };

package/providers/inventory.provider.js

@@ -1,11 +1,24 @@
+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 {
-  InventoryIdentifierSchema,
-  InventoryProvider
+  InventoryProvider,
+  InventoryQueryBySKUSchema,
+  InventorySchema,
+  Reactionary
 } from "@reactionary/core";
 class FakeInventoryProvider extends InventoryProvider {
-  constructor(config, schema, cache, context) {
-    super(schema, cache, context);
+  constructor(config, cache, context) {
+    super(cache, context);
     this.config = config;
   }
   async getBySKU(payload) {
@@ -19,27 +32,37 @@ class FakeInventoryProvider extends InventoryProvider {
       seed: hash || 42,
       locale: [en, base]
     });
-    const model = this.newModel();
-    model.identifier = InventoryIdentifierSchema.parse({
+    const identifier = {
       variant: payload.variant,
       fulfillmentCenter: payload.fulfilmentCenter
-    });
-    model.quantity = generator.number.int({ min: 0, max: 100 });
-    if (model.quantity > 0) {
-      model.status = "inStock";
-    } else {
-      model.status = "outOfStock";
+    };
+    const quantity = generator.number.int({ min: 0, max: 100 });
+    let status = "outOfStock";
+    if (quantity > 0) {
+      status = "inStock";
     }
-    model.meta = {
+    const meta = {
       cache: {
         hit: false,
-        key: this.generateCacheKeySingle(model.identifier)
+        key: this.generateCacheKeySingle(identifier)
       },
       placeholder: false
     };
-    return this.assert(model);
+    const result = {
+      identifier,
+      meta,
+      quantity,
+      status
+    };
+    return result;
   }
 }
+__decorateClass([
+  Reactionary({
+    inputSchema: InventoryQueryBySKUSchema,
+    outputSchema: InventorySchema
+  })
+], FakeInventoryProvider.prototype, "getBySKU", 1);
 export {
   FakeInventoryProvider
 };

package/providers/price.provider.js

@@ -1,10 +1,25 @@
+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 {
-  PriceProvider
+  PriceProvider,
+  Reactionary,
+  CustomerPriceQuerySchema,
+  PriceSchema,
+  ListPriceQuerySchema
 } from "@reactionary/core";
 import { base, en, Faker } from "@faker-js/faker";
 class FakePriceProvider extends PriceProvider {
-  constructor(config, schema, cache, context) {
-    super(schema, cache, context);
+  constructor(config, cache, context) {
+    super(cache, context);
     this.config = config;
   }
   async getListPrice(payload) {
@@ -21,8 +36,7 @@ class FakePriceProvider extends PriceProvider {
       seed: hash || 42,
       locale: [en, base]
     });
-    const model = this.newModel();
-    Object.assign(model, {
+    const model = {
       identifier: {
         variant: payload.variant
       },
@@ -37,7 +51,7 @@ class FakePriceProvider extends PriceProvider {
         },
         placeholder: false
       }
-    });
+    };
     if (skuString.includes("with-tiers")) {
       const unitPrice = model.unitPrice?.value || 0;
       const tier1Price = unitPrice * 0.8;
@@ -61,7 +75,7 @@ class FakePriceProvider extends PriceProvider {
     } else {
       model.tieredPrices = [];
     }
-    return this.assert(model);
+    return model;
   }
   async getCustomerPrice(payload) {
     if (payload.variant.sku === "unknown-sku") {
@@ -77,8 +91,7 @@ class FakePriceProvider extends PriceProvider {
       seed: hash || 42,
       locale: [en, base]
     });
-    const model = this.newModel();
-    Object.assign(model, {
+    const model = {
       identifier: {
         variant: payload.variant
       },
@@ -93,7 +106,7 @@ class FakePriceProvider extends PriceProvider {
         },
         placeholder: false
       }
-    });
+    };
     if (skuString.includes("with-tiers")) {
       const unitPrice = model.unitPrice?.value || 0;
       const tier1Price = unitPrice * 0.8;
@@ -117,9 +130,21 @@ class FakePriceProvider extends PriceProvider {
     } else {
       model.tieredPrices = [];
     }
-    return this.assert(model);
+    return model;
   }
 }
+__decorateClass([
+  Reactionary({
+    inputSchema: ListPriceQuerySchema,
+    outputSchema: PriceSchema
+  })
+], FakePriceProvider.prototype, "getListPrice", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CustomerPriceQuerySchema,
+    outputSchema: PriceSchema
+  })
+], FakePriceProvider.prototype, "getCustomerPrice", 1);
 export {
   FakePriceProvider
 };

package/providers/product-search.provider.js

@@ -1,14 +1,27 @@
+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,
   ProductSearchProvider,
+  ProductSearchQueryByTermSchema,
   ProductSearchResultItemSchema,
-  ProductSearchResultSchema
+  ProductSearchResultSchema,
+  Reactionary
 } from "@reactionary/core";
 import { Faker, en, base } from "@faker-js/faker";
 import { jitter } from "../utilities/jitter.js";
 class FakeSearchProvider extends ProductSearchProvider {
-  constructor(config, schema, cache, context) {
-    super(schema, cache, context);
+  constructor(config, cache, context) {
+    super(cache, context);
     this.config = config;
   }
   async queryByTerm(payload) {
@@ -47,7 +60,6 @@ class FakeSearchProvider extends ProductSearchProvider {
             identifier: {
               key: "product_" + productGenerator.commerce.isbn()
             },
-            image: img,
             name: productGenerator.commerce.productName(),
             slug: productGenerator.lorem.slug(),
             variants: [{
@@ -130,6 +142,12 @@ class FakeSearchProvider extends ProductSearchProvider {
     return foo;
   }
 }
+__decorateClass([
+  Reactionary({
+    inputSchema: ProductSearchQueryByTermSchema,
+    outputSchema: ProductSearchResultSchema
+  })
+], FakeSearchProvider.prototype, "queryByTerm", 1);
 export {
   FakeSearchProvider
 };

package/providers/product.provider.js

@@ -11,12 +11,16 @@ var __decorateClass = (decorators, target, key, kind) => {
 };
 import {
   ProductProvider,
-  Reactionary
+  Reactionary,
+  ProductQueryByIdSchema,
+  ProductSchema,
+  ProductQueryBySlugSchema,
+  ProductQueryBySKUSchema
 } from "@reactionary/core";
 import { base, en, Faker } from "@faker-js/faker";
 class FakeProductProvider extends ProductProvider {
-  constructor(config, schema, cache, context) {
-    super(schema, cache, context);
+  constructor(config, cache, context) {
+    super(cache, context);
     this.config = config;
   }
   async getById(payload) {
@@ -34,40 +38,60 @@ class FakeProductProvider extends ProductProvider {
       locale: [en, base]
     });
     const key = body;
-    const model = this.newModel();
-    Object.assign(model, {
+    const result = {
       identifier: {
         key
       },
       name: generator.commerce.productName(),
       slug: key,
-      attributes: [],
+      brand: "",
+      longDescription: "",
+      mainVariant: {
+        barcode: "",
+        ean: "",
+        gtin: "",
+        identifier: {
+          sku: ""
+        },
+        images: [],
+        name: "",
+        options: [],
+        upc: ""
+      },
       description: generator.commerce.productDescription(),
-      image: generator.image.urlPicsumPhotos({
-        width: 600,
-        height: 600
-      }),
-      images: [],
+      manufacturer: "",
+      options: [],
+      parentCategories: [],
+      published: true,
+      sharedAttributes: [],
       meta: {
         cache: {
           hit: false,
           key
         },
         placeholder: false
-      },
-      skus: []
-    });
-    return this.assert(model);
+      }
+    };
+    return result;
   }
 }
 __decorateClass([
-  Reactionary({})
+  Reactionary({
+    inputSchema: ProductQueryByIdSchema,
+    outputSchema: ProductSchema
+  })
 ], FakeProductProvider.prototype, "getById", 1);
 __decorateClass([
-  Reactionary({})
+  Reactionary({
+    inputSchema: ProductQueryBySlugSchema,
+    outputSchema: ProductSchema
+  })
 ], FakeProductProvider.prototype, "getBySlug", 1);
 __decorateClass([
-  Reactionary({})
+  Reactionary({
+    inputSchema: ProductQueryBySKUSchema,
+    outputSchema: ProductSchema
+  })
 ], FakeProductProvider.prototype, "getBySKU", 1);
 export {
   FakeProductProvider

package/providers/store.provider.js

@@ -1,8 +1,20 @@
-import { StoreProvider } from "@reactionary/core";
+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, StoreProvider, StoreQueryByProximitySchema, StoreSchema } from "@reactionary/core";
+import z from "zod";
 import { base, en, Faker } from "@faker-js/faker";
 class FakeStoreProvider extends StoreProvider {
-  constructor(config, schema, cache, context) {
-    super(schema, cache, context);
+  constructor(config, cache, context) {
+    super(cache, context);
     this.config = config;
   }
   async queryByProximity(payload) {
@@ -10,17 +22,38 @@ class FakeStoreProvider extends StoreProvider {
       seed: 42,
       locale: [en, base]
     });
-    const results = [];
+    const results = new Array();
     for (let i = 0; i < payload.limit; i++) {
-      const model = this.newModel();
-      model.name = generator.company.name();
-      model.identifier.key = "" + i;
-      model.fulfillmentCenter.key = "" + i;
-      results.push(model);
+      const name = generator.company.name();
+      const identifier = {
+        key: "" + i
+      };
+      const fulfillmentCenter = {
+        key: "" + i
+      };
+      const meta = {
+        cache: {
+          hit: false,
+          key: "" + i
+        },
+        placeholder: false
+      };
+      results.push({
+        fulfillmentCenter,
+        identifier,
+        meta,
+        name
+      });
     }
     return results;
   }
 }
+__decorateClass([
+  Reactionary({
+    inputSchema: StoreQueryByProximitySchema,
+    outputSchema: z.array(StoreSchema)
+  })
+], FakeStoreProvider.prototype, "queryByProximity", 1);
 export {
   FakeStoreProvider
 };

package/src/providers/analytics.provider.d.ts

@@ -1,8 +1,7 @@
-import type { BaseModel, Cache, RequestContext } from '@reactionary/core';
+import type { Cache, RequestContext } from '@reactionary/core';
 import { AnalyticsProvider } from '@reactionary/core';
-import type z from 'zod';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
-export declare class FakeAnalyticsProvider<T extends BaseModel = BaseModel> extends AnalyticsProvider<T> {
+export declare class FakeAnalyticsProvider extends AnalyticsProvider {
     protected config: FakeConfiguration;
-    constructor(config: FakeConfiguration, schema: z.ZodType<T>, cache: Cache, context: RequestContext);
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext);
 }

package/src/providers/cart.provider.d.ts

@@ -1,20 +1,19 @@
 import type { Cart, CartQueryById, CartMutationItemAdd, CartMutationItemRemove, CartMutationItemQuantityChange, RequestContext, Cache, CartIdentifier, CartMutationApplyCoupon, CartMutationChangeCurrency, CartMutationDeleteCart, CartMutationRemoveCoupon } from '@reactionary/core';
 import { CartProvider } from '@reactionary/core';
-import type z from 'zod';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
-export declare class FakeCartProvider<T extends Cart = Cart> extends CartProvider<T> {
+export declare class FakeCartProvider extends CartProvider {
     protected config: FakeConfiguration;
     private carts;
     private generator;
-    constructor(config: FakeConfiguration, schema: z.ZodType<T>, cache: Cache, context: RequestContext);
-    getById(payload: CartQueryById): Promise<T>;
-    add(payload: CartMutationItemAdd): Promise<T>;
-    remove(payload: CartMutationItemRemove): Promise<T>;
-    changeQuantity(payload: CartMutationItemQuantityChange): Promise<T>;
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext);
+    getById(payload: CartQueryById): Promise<Cart>;
+    add(payload: CartMutationItemAdd): Promise<Cart>;
+    remove(payload: CartMutationItemRemove): Promise<Cart>;
+    changeQuantity(payload: CartMutationItemQuantityChange): Promise<Cart>;
     getActiveCartId(): Promise<CartIdentifier>;
-    deleteCart(payload: CartMutationDeleteCart): Promise<T>;
-    applyCouponCode(payload: CartMutationApplyCoupon): Promise<T>;
-    removeCouponCode(payload: CartMutationRemoveCoupon): Promise<T>;
-    changeCurrency(payload: CartMutationChangeCurrency): Promise<T>;
-    protected recalculateCart(cart: T): void;
+    deleteCart(payload: CartMutationDeleteCart): Promise<Cart>;
+    applyCouponCode(payload: CartMutationApplyCoupon): Promise<Cart>;
+    removeCouponCode(payload: CartMutationRemoveCoupon): Promise<Cart>;
+    changeCurrency(payload: CartMutationChangeCurrency): Promise<Cart>;
+    protected recalculateCart(cart: Cart): void;
 }

package/src/providers/category.provider.d.ts

@@ -1,20 +1,88 @@
-import type { Category, CategoryQueryById, CategoryQueryBySlug, CategoryQueryForBreadcrumb, CategoryQueryForChildCategories, CategoryQueryForTopCategories, RequestContext } from "@reactionary/core";
+import type { Category, CategoryPaginatedResult, CategoryQueryById, CategoryQueryBySlug, CategoryQueryForBreadcrumb, CategoryQueryForChildCategories, CategoryQueryForTopCategories, RequestContext } from "@reactionary/core";
 import { CategoryProvider } from "@reactionary/core";
 import type { FakeConfiguration } from "../schema/configuration.schema.js";
 import type { Cache as ReactionaryCache } from "@reactionary/core";
-import type z from "zod";
 import { Faker } from '@faker-js/faker';
-export declare class FakeCategoryProvider<T extends Category = Category> extends CategoryProvider<T> {
+export declare class FakeCategoryProvider extends CategoryProvider {
     protected config: FakeConfiguration;
-    protected topCategories: T[];
-    protected childCategories: Map<string, T[]>;
-    protected allCategories: Map<string, T>;
+    protected topCategories: {
+        meta: {
+            cache: {
+                hit: boolean;
+                key: string;
+            };
+            placeholder: boolean;
+        };
+        identifier: {
+            key: string;
+        };
+        name: string;
+        slug: string;
+        text: string;
+        images: {
+            sourceUrl: string;
+            altText: string;
+            width: number;
+            height: number;
+        }[];
+        parentCategory?: {
+            key: string;
+        } | undefined;
+    }[];
+    protected childCategories: Map<string, {
+        meta: {
+            cache: {
+                hit: boolean;
+                key: string;
+            };
+            placeholder: boolean;
+        };
+        identifier: {
+            key: string;
+        };
+        name: string;
+        slug: string;
+        text: string;
+        images: {
+            sourceUrl: string;
+            altText: string;
+            width: number;
+            height: number;
+        }[];
+        parentCategory?: {
+            key: string;
+        } | undefined;
+    }[]>;
+    protected allCategories: Map<string, {
+        meta: {
+            cache: {
+                hit: boolean;
+                key: string;
+            };
+            placeholder: boolean;
+        };
+        identifier: {
+            key: string;
+        };
+        name: string;
+        slug: string;
+        text: string;
+        images: {
+            sourceUrl: string;
+            altText: string;
+            width: number;
+            height: number;
+        }[];
+        parentCategory?: {
+            key: string;
+        } | undefined;
+    }>;
     protected categoryGenerator: Faker;
-    protected generateFakeCategory(parent: Category | undefined, index: number): T;
-    constructor(config: FakeConfiguration, schema: z.ZodType<T>, cache: ReactionaryCache, context: RequestContext);
-    getById(payload: CategoryQueryById): Promise<T>;
-    getBySlug(payload: CategoryQueryBySlug): Promise<T | null>;
-    getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb): Promise<T[]>;
-    findChildCategories(payload: CategoryQueryForChildCategories): Promise<ReturnType<typeof this.parsePaginatedResult>>;
-    findTopCategories(payload: CategoryQueryForTopCategories): Promise<ReturnType<typeof this.parsePaginatedResult>>;
+    protected generateFakeCategory(parent: Category | undefined, index: number): Category;
+    constructor(config: FakeConfiguration, cache: ReactionaryCache, context: RequestContext);
+    getById(payload: CategoryQueryById): Promise<Category>;
+    getBySlug(payload: CategoryQueryBySlug): Promise<Category | null>;
+    getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb): Promise<Category[]>;
+    findChildCategories(payload: CategoryQueryForChildCategories): Promise<CategoryPaginatedResult>;
+    findTopCategories(payload: CategoryQueryForTopCategories): Promise<CategoryPaginatedResult>;
 }

package/src/providers/identity.provider.d.ts

@@ -1,12 +1,11 @@
 import { type Identity, type IdentityQuerySelf, type IdentityMutationLogin, type IdentityMutationLogout, type RequestContext, type Cache, IdentityProvider, type IdentityMutationRegister } from '@reactionary/core';
-import type z from 'zod';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
-export declare class FakeIdentityProvider<T extends Identity = Identity> extends IdentityProvider<T> {
+export declare class FakeIdentityProvider extends IdentityProvider {
     protected config: FakeConfiguration;
     private currentIdentity;
-    constructor(config: FakeConfiguration, schema: z.ZodType<T>, cache: Cache, context: RequestContext);
-    getSelf(_payload: IdentityQuerySelf): Promise<T>;
-    login(payload: IdentityMutationLogin): Promise<T>;
-    logout(_payload: IdentityMutationLogout): Promise<T>;
-    register(payload: IdentityMutationRegister): Promise<T>;
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext);
+    getSelf(_payload: IdentityQuerySelf): Promise<Identity>;
+    login(payload: IdentityMutationLogin): Promise<Identity>;
+    logout(_payload: IdentityMutationLogout): Promise<Identity>;
+    register(payload: IdentityMutationRegister): Promise<Identity>;
 }

package/src/providers/inventory.provider.d.ts

@@ -1,9 +1,8 @@
 import type { Cache, Inventory, InventoryQueryBySKU, RequestContext } from '@reactionary/core';
 import { InventoryProvider } from '@reactionary/core';
-import type z from 'zod';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
-export declare class FakeInventoryProvider<T extends Inventory = Inventory> extends InventoryProvider<T> {
+export declare class FakeInventoryProvider extends InventoryProvider {
     protected config: FakeConfiguration;
-    constructor(config: FakeConfiguration, schema: z.ZodType<T>, cache: Cache, context: RequestContext);
-    getBySKU(payload: InventoryQueryBySKU): Promise<T>;
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext);
+    getBySKU(payload: InventoryQueryBySKU): Promise<Inventory>;
 }

package/src/providers/price.provider.d.ts

@@ -1,9 +1,8 @@
-import { type Price, type RequestContext, type Cache, PriceProvider, type CustomerPriceQuery, type ListPriceQuery } from '@reactionary/core';
-import type z from 'zod';
+import { type RequestContext, type Cache, PriceProvider, type CustomerPriceQuery, type ListPriceQuery, type Price } from '@reactionary/core';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
-export declare class FakePriceProvider<T extends Price = Price> extends PriceProvider<T> {
+export declare class FakePriceProvider extends PriceProvider {
     protected config: FakeConfiguration;
-    constructor(config: FakeConfiguration, schema: z.ZodType<T>, cache: Cache, context: RequestContext);
-    getListPrice(payload: ListPriceQuery): Promise<T>;
-    getCustomerPrice(payload: CustomerPriceQuery): Promise<T>;
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext);
+    getListPrice(payload: ListPriceQuery): Promise<Price>;
+    getCustomerPrice(payload: CustomerPriceQuery): Promise<Price>;
 }

package/src/providers/product-search.provider.d.ts

@@ -1,11 +1,10 @@
 import { ProductSearchProvider } from '@reactionary/core';
-import type { ProductSearchResult, ProductSearchResultFacet, ProductSearchResultItem, Cache as ReactionaryCache, FacetIdentifier, FacetValueIdentifier, ProductSearchResultFacetValue, ProductSearchResultItemVariant } from '@reactionary/core';
+import type { ProductSearchResult, ProductSearchResultFacet, Cache as ReactionaryCache, FacetIdentifier, FacetValueIdentifier, ProductSearchResultFacetValue, ProductSearchResultItemVariant } from '@reactionary/core';
 import type { RequestContext, ProductSearchQueryByTerm } from '@reactionary/core';
-import type z from 'zod';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
-export declare class FakeSearchProvider<T extends ProductSearchResultItem = ProductSearchResultItem> extends ProductSearchProvider<T> {
+export declare class FakeSearchProvider extends ProductSearchProvider {
     protected config: FakeConfiguration;
-    constructor(config: FakeConfiguration, schema: z.ZodType<T>, cache: ReactionaryCache, context: RequestContext);
+    constructor(config: FakeConfiguration, cache: ReactionaryCache, context: RequestContext);
     queryByTerm(payload: ProductSearchQueryByTerm): Promise<ProductSearchResult>;
     protected parseFacetValue(facetValueIdentifier: FacetValueIdentifier, label: string, count: number): ProductSearchResultFacetValue;
     protected parseFacet(facetIdentifier: FacetIdentifier, facetValue: unknown): ProductSearchResultFacet;

package/src/providers/product.provider.d.ts

@@ -1,11 +1,10 @@
-import { type Product, type ProductQueryById, type ProductQueryBySlug, type RequestContext, type Cache as ReactinaryCache, ProductProvider, type ProductQueryBySKU } from '@reactionary/core';
-import type z from 'zod';
+import { type ProductQueryById, type ProductQueryBySlug, type RequestContext, type Cache as ReactinaryCache, ProductProvider, type ProductQueryBySKU, type Product } from '@reactionary/core';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
-export declare class FakeProductProvider<T extends Product = Product> extends ProductProvider<T> {
+export declare class FakeProductProvider extends ProductProvider {
     protected config: FakeConfiguration;
-    constructor(config: FakeConfiguration, schema: z.ZodType<T>, cache: ReactinaryCache, context: RequestContext);
-    getById(payload: ProductQueryById): Promise<T>;
-    getBySlug(payload: ProductQueryBySlug): Promise<T>;
-    getBySKU(payload: ProductQueryBySKU): Promise<T>;
-    protected parseSingle(body: string): T;
+    constructor(config: FakeConfiguration, cache: ReactinaryCache, context: RequestContext);
+    getById(payload: ProductQueryById): Promise<Product>;
+    getBySlug(payload: ProductQueryBySlug): Promise<Product>;
+    getBySKU(payload: ProductQueryBySKU): Promise<Product>;
+    protected parseSingle(body: string): Product;
 }

package/src/providers/store.provider.d.ts

@@ -1,9 +1,8 @@
-import type { Cache, RequestContext, StoreQueryByProximity, Store } from '@reactionary/core';
+import type { Cache, RequestContext, Store, StoreQueryByProximity } from '@reactionary/core';
 import { StoreProvider } from '@reactionary/core';
-import type z from 'zod';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
-export declare class FakeStoreProvider<T extends Store = Store> extends StoreProvider<T> {
+export declare class FakeStoreProvider extends StoreProvider {
     protected config: FakeConfiguration;
-    constructor(config: FakeConfiguration, schema: z.ZodType<T>, cache: Cache, context: RequestContext);
-    queryByProximity(payload: StoreQueryByProximity): Promise<T[]>;
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext);
+    queryByProximity(payload: StoreQueryByProximity): Promise<Store[]>;
 }

package/src/schema/capabilities.schema.d.ts

@@ -4,9 +4,9 @@ export declare const FakeCapabilitiesSchema: z.ZodObject<{
     product: z.ZodOptional<z.ZodBoolean>;
     identity: z.ZodOptional<z.ZodBoolean>;
     cart: z.ZodOptional<z.ZodBoolean>;
+    productSearch: z.ZodOptional<z.ZodBoolean>;
     inventory: z.ZodOptional<z.ZodBoolean>;
     category: z.ZodOptional<z.ZodBoolean>;
     store: z.ZodOptional<z.ZodBoolean>;
-    productSearch: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$loose>;
 export type FakeCapabilities = z.infer<typeof FakeCapabilitiesSchema>;