@reactionary/provider-fake 0.1.13 → 0.2.2

package/package.json

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

package/providers/cart.provider.js

@@ -21,7 +21,10 @@ import {
   CartProvider,
   CartQueryByIdSchema,
   CartSchema,
-  Reactionary
+  Reactionary,
+  error,
+  success,
+  unwrapValue
 } from "@reactionary/core";
 import { Faker, en, base } from "@faker-js/faker";
 class FakeCartProvider extends CartProvider {
@@ -37,7 +40,10 @@ class FakeCartProvider extends CartProvider {
   async getById(payload) {
     const cartId = payload.cart.key;
     if (payload.cart.key === "") {
-      return this.createEmptyCart();
+      return error({
+        type: "NotFound",
+        identifier: cartId
+      });
     }
     if (!this.carts.has(cartId)) {
       const cart2 = this.createEmptyCart();
@@ -48,14 +54,13 @@ class FakeCartProvider extends CartProvider {
     if (!cart) {
       throw new Error(`Cart with id ${cartId} not found`);
     }
-    return cart;
+    return success(cart);
   }
   async add(payload) {
-    const cartId = payload.cart.key || `cart-${this.generator.string.uuid()}`;
-    const cart = await this.getById({ cart: { key: cartId } });
-    if (cart.meta.placeholder) {
+    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;
-      cart.meta.placeholder = false;
       this.carts.set(cartId, cart);
     }
     const existingItemIndex = cart.items.findIndex(
@@ -94,31 +99,31 @@ class FakeCartProvider extends CartProvider {
       });
     }
     this.recalculateCart(cart);
-    return cart;
+    return success(cart);
   }
   async remove(payload) {
     const cartId = payload.cart.key || `cart-${this.generator.string.uuid()}`;
-    const cart = await this.getById({ cart: { key: cartId } });
+    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 cart;
+    return success(cart);
   }
   async changeQuantity(payload) {
     const cartId = payload.cart.key || `cart-${this.generator.string.uuid()}`;
-    const cart = await this.getById({ cart: { key: cartId } });
+    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 cart;
+      return success(cart);
     }
     if (item) {
       item.quantity = payload.quantity;
     }
     this.recalculateCart(cart);
-    return cart;
+    return success(cart);
   }
   getActiveCartId() {
     throw new Error("Method not implemented.");
@@ -140,14 +145,58 @@ class FakeCartProvider extends CartProvider {
       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),
+      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),
+      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"
+        }
+      },
+      userId: {
+        userId: ""
+      }
+    };
+    return cart;
+  }
 }
 __decorateClass([
   Reactionary({

package/providers/category.provider.js

@@ -9,7 +9,7 @@ var __decorateClass = (decorators, target, key, kind) => {
     __defProp(target, key, result);
   return result;
 };
-import { CategoryPaginatedResultSchema, CategoryProvider, CategoryQueryByIdSchema, CategoryQueryBySlugSchema, CategoryQueryForBreadcrumbSchema, CategoryQueryForChildCategoriesSchema, CategoryQueryForTopCategoriesSchema, CategorySchema, Reactionary } from "@reactionary/core";
+import { success, error, 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 {
@@ -59,13 +59,6 @@ class FakeCategoryProvider extends CategoryProvider {
     const category = {
       identifier,
       images: [],
-      meta: {
-        cache: {
-          hit: false,
-          key: ""
-        },
-        placeholder: false
-      },
       name,
       slug,
       text,
@@ -77,19 +70,25 @@ class FakeCategoryProvider extends CategoryProvider {
   async getById(payload) {
     const category = this.allCategories.get(payload.id.key);
     if (!category) {
-      throw new Error("This should not happen...");
+      return error({
+        type: "NotFound",
+        identifier: payload
+      });
     }
-    return category;
+    return success(category);
   }
-  getBySlug(payload) {
+  async getBySlug(payload) {
     for (const p of this.allCategories.values()) {
       if (p.slug === payload.slug) {
-        return Promise.resolve(p);
+        return success(p);
       }
     }
-    return Promise.resolve(null);
+    return error({
+      type: "NotFound",
+      identifier: payload
+    });
   }
-  getBreadcrumbPathToCategory(payload) {
+  async getBreadcrumbPathToCategory(payload) {
     const path = new Array();
     let category = this.allCategories.get(payload.id.key);
     path.push(category);
@@ -99,7 +98,7 @@ class FakeCategoryProvider extends CategoryProvider {
         path.unshift(category);
       }
     }
-    return Promise.resolve(path);
+    return success(path);
   }
   async findChildCategories(payload) {
     const children = this.childCategories.get(payload.parentId.key);
@@ -118,9 +117,9 @@ class FakeCategoryProvider extends CategoryProvider {
       pageSize: payload.paginationOptions.pageSize,
       totalPages: children ? Math.ceil(children.length / payload.paginationOptions.pageSize) : 1
     };
-    return Promise.resolve(res);
+    return success(res);
   }
-  findTopCategories(payload) {
+  async findTopCategories(payload) {
     const children = this.topCategories;
     const page = children?.slice((payload.paginationOptions.pageNumber - 1) * payload.paginationOptions.pageSize, payload.paginationOptions.pageNumber * payload.paginationOptions.pageSize);
     const res = {
@@ -137,7 +136,7 @@ class FakeCategoryProvider extends CategoryProvider {
       pageSize: payload.paginationOptions.pageSize,
       totalPages: children ? Math.ceil(children.length / payload.paginationOptions.pageSize) : 1
     };
-    return Promise.resolve(res);
+    return success(res);
   }
 }
 __decorateClass([

package/providers/identity.provider.js

@@ -16,7 +16,8 @@ import {
   IdentitySchema,
   IdentityMutationLogoutSchema,
   IdentityMutationLoginSchema,
-  IdentityQuerySelfSchema
+  IdentityQuerySelfSchema,
+  success
 } from "@reactionary/core";
 import { base, en, Faker } from "@faker-js/faker";
 class FakeIdentityProvider extends IdentityProvider {
@@ -28,18 +29,11 @@ class FakeIdentityProvider extends IdentityProvider {
   async getSelf(_payload) {
     if (!this.currentIdentity) {
       const model = {
-        type: "Anonymous",
-        meta: {
-          cache: {
-            hit: false,
-            key: "anonymous"
-          },
-          placeholder: false
-        }
+        type: "Anonymous"
       };
       this.currentIdentity = model;
     }
-    return this.currentIdentity;
+    return success(this.currentIdentity);
   }
   async login(payload) {
     const generator = new Faker({
@@ -50,31 +44,17 @@ class FakeIdentityProvider extends IdentityProvider {
       type: "Registered",
       id: {
         userId: generator.string.alphanumeric(32)
-      },
-      meta: {
-        cache: {
-          hit: false,
-          key: payload.username
-        },
-        placeholder: false
       }
     };
     this.currentIdentity = model;
-    return this.currentIdentity;
+    return success(this.currentIdentity);
   }
   async logout(_payload) {
     const model = {
-      type: "Anonymous",
-      meta: {
-        cache: {
-          hit: false,
-          key: "anonymous"
-        },
-        placeholder: false
-      }
+      type: "Anonymous"
     };
     this.currentIdentity = model;
-    return this.currentIdentity;
+    return success(this.currentIdentity);
   }
   register(payload) {
     throw new Error("Method not implemented.");

package/providers/inventory.provider.js

@@ -14,7 +14,8 @@ import {
   InventoryProvider,
   InventoryQueryBySKUSchema,
   InventorySchema,
-  Reactionary
+  Reactionary,
+  success
 } from "@reactionary/core";
 class FakeInventoryProvider extends InventoryProvider {
   constructor(config, cache, context) {
@@ -41,20 +42,12 @@ class FakeInventoryProvider extends InventoryProvider {
     if (quantity > 0) {
       status = "inStock";
     }
-    const meta = {
-      cache: {
-        hit: false,
-        key: this.generateCacheKeySingle(identifier)
-      },
-      placeholder: false
-    };
     const result = {
       identifier,
-      meta,
       quantity,
       status
     };
-    return result;
+    return success(result);
   }
 }
 __decorateClass([

package/providers/price.provider.js

@@ -14,7 +14,9 @@ import {
   Reactionary,
   CustomerPriceQuerySchema,
   PriceSchema,
-  ListPriceQuerySchema
+  ListPriceQuerySchema,
+  error,
+  success
 } from "@reactionary/core";
 import { base, en, Faker } from "@faker-js/faker";
 class FakePriceProvider extends PriceProvider {
@@ -24,7 +26,7 @@ class FakePriceProvider extends PriceProvider {
   }
   async getListPrice(payload) {
     if (payload.variant.sku === "unknown-sku") {
-      return this.createEmptyPriceResult(payload.variant.sku);
+      return success(this.createEmptyPriceResult(payload.variant.sku));
     }
     let hash = 0;
     const skuString = payload.variant.sku;
@@ -43,13 +45,6 @@ class FakePriceProvider extends PriceProvider {
       unitPrice: {
         value: generator.number.int({ min: 300, max: 1e5 }) / 100,
         currency: this.context.languageContext.currencyCode
-      },
-      meta: {
-        cache: {
-          hit: false,
-          key: payload.variant.sku
-        },
-        placeholder: false
       }
     };
     if (skuString.includes("with-tiers")) {
@@ -75,11 +70,11 @@ class FakePriceProvider extends PriceProvider {
     } else {
       model.tieredPrices = [];
     }
-    return model;
+    return success(model);
   }
   async getCustomerPrice(payload) {
     if (payload.variant.sku === "unknown-sku") {
-      return this.createEmptyPriceResult(payload.variant.sku);
+      return success(this.createEmptyPriceResult(payload.variant.sku));
     }
     let hash = 0;
     const skuString = payload.variant.sku;
@@ -98,13 +93,6 @@ class FakePriceProvider extends PriceProvider {
       unitPrice: {
         value: generator.number.int({ min: 300, max: 1e5 }) / 100,
         currency: this.context.languageContext.currencyCode
-      },
-      meta: {
-        cache: {
-          hit: false,
-          key: payload.variant.sku
-        },
-        placeholder: false
       }
     };
     if (skuString.includes("with-tiers")) {
@@ -130,7 +118,7 @@ class FakePriceProvider extends PriceProvider {
     } else {
       model.tieredPrices = [];
     }
-    return model;
+    return success(model);
   }
 }
 __decorateClass([

package/providers/product-search.provider.js

@@ -15,7 +15,9 @@ import {
   ProductSearchQueryByTermSchema,
   ProductSearchResultItemSchema,
   ProductSearchResultSchema,
-  Reactionary
+  Reactionary,
+  success,
+  error
 } from "@reactionary/core";
 import { Faker, en, base } from "@faker-js/faker";
 import { jitter } from "../utilities/jitter.js";
@@ -32,15 +34,20 @@ class FakeSearchProvider extends ProductSearchProvider {
       facet: facetIdentifier,
       key: payload.categoryPath[payload.categoryPath.length - 1].identifier.key
     };
-    return facetValueIdentifier;
+    return success(facetValueIdentifier);
   }
   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 totalPages = Math.ceil(
+      totalProducts / query.paginationOptions.pageSize
+    );
+    const productsOnPage = Math.min(
+      totalProducts,
+      query.paginationOptions.pageSize
+    );
     const productGenerator = new Faker({
       seed: querySpecificity,
       locale: [en, base]
@@ -65,22 +72,22 @@ class FakeSearchProvider extends ProductSearchProvider {
         width: 300
       });
       products.push(
-        ProductSearchResultItemSchema.parse(
-          {
-            identifier: {
-              key: "product_" + productGenerator.commerce.isbn()
-            },
-            name: productGenerator.commerce.productName(),
-            slug: productGenerator.lorem.slug(),
-            variants: [{
+        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
-            }]
-          }
-        )
+            }
+          ]
+        })
       );
     }
     const facetBase = ["color", "size"];
@@ -126,17 +133,9 @@ class FakeSearchProvider extends ProductSearchProvider {
       pageNumber: query.paginationOptions.pageNumber,
       pageSize: query.paginationOptions.pageSize,
       totalCount: totalProducts,
-      totalPages,
-      meta: {
-        cache: {
-          hit: false,
-          key: ""
-        },
-        placeholder: false
-      }
+      totalPages
     });
-    const foo = this.childFunction();
-    return result;
+    return success(result);
   }
   parseFacetValue(facetValueIdentifier, label, count) {
     throw new Error("Method not implemented.");
@@ -147,10 +146,6 @@ class FakeSearchProvider extends ProductSearchProvider {
   parseVariant(variant, product) {
     throw new Error("Method not implemented.");
   }
-  childFunction() {
-    const foo = 42;
-    return foo;
-  }
 }
 __decorateClass([
   Reactionary({

package/providers/product.provider.js

@@ -15,7 +15,9 @@ import {
   ProductQueryByIdSchema,
   ProductSchema,
   ProductQueryBySlugSchema,
-  ProductQueryBySKUSchema
+  ProductQueryBySKUSchema,
+  error,
+  success
 } from "@reactionary/core";
 import { base, en, Faker } from "@faker-js/faker";
 class FakeProductProvider extends ProductProvider {
@@ -24,13 +26,13 @@ class FakeProductProvider extends ProductProvider {
     this.config = config;
   }
   async getById(payload) {
-    return this.parseSingle(payload.identifier.key);
+    return success(this.parseSingle(payload.identifier.key));
   }
   async getBySlug(payload) {
-    return this.parseSingle(payload.slug);
+    return success(this.parseSingle(payload.slug));
   }
   async getBySKU(payload) {
-    return this.parseSingle(payload.variant.sku);
+    return success(this.parseSingle(payload.variant.sku));
   }
   parseSingle(body) {
     const generator = new Faker({
@@ -64,14 +66,7 @@ class FakeProductProvider extends ProductProvider {
       parentCategories: [],
       published: true,
       sharedAttributes: [],
-      variants: [],
-      meta: {
-        cache: {
-          hit: false,
-          key
-        },
-        placeholder: false
-      }
+      variants: []
     };
     return result;
   }

package/providers/store.provider.js

@@ -9,7 +9,7 @@ var __decorateClass = (decorators, target, key, kind) => {
     __defProp(target, key, result);
   return result;
 };
-import { Reactionary, StoreProvider, StoreQueryByProximitySchema, StoreSchema } from "@reactionary/core";
+import { Reactionary, StoreProvider, StoreQueryByProximitySchema, StoreSchema, success } from "@reactionary/core";
 import z from "zod";
 import { base, en, Faker } from "@faker-js/faker";
 class FakeStoreProvider extends StoreProvider {
@@ -31,21 +31,13 @@ class FakeStoreProvider extends StoreProvider {
       const fulfillmentCenter = {
         key: "" + i
       };
-      const meta = {
-        cache: {
-          hit: false,
-          key: "" + i
-        },
-        placeholder: false
-      };
       results.push({
         fulfillmentCenter,
         identifier,
-        meta,
         name
       });
     }
-    return results;
+    return success(results);
   }
 }
 __decorateClass([

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

@@ -1,4 +1,4 @@
-import type { Cart, CartQueryById, CartMutationItemAdd, CartMutationItemRemove, CartMutationItemQuantityChange, RequestContext, Cache, CartIdentifier, CartMutationApplyCoupon, CartMutationChangeCurrency, CartMutationDeleteCart, CartMutationRemoveCoupon } from '@reactionary/core';
+import type { Cart, CartQueryById, CartMutationItemAdd, CartMutationItemRemove, CartMutationItemQuantityChange, RequestContext, Cache, CartIdentifier, CartMutationApplyCoupon, CartMutationChangeCurrency, CartMutationDeleteCart, CartMutationRemoveCoupon, Result, NotFoundError } from '@reactionary/core';
 import { CartProvider } from '@reactionary/core';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
 export declare class FakeCartProvider extends CartProvider {
@@ -6,14 +6,15 @@ export declare class FakeCartProvider extends CartProvider {
     private carts;
     private generator;
     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<Cart>;
-    applyCouponCode(payload: CartMutationApplyCoupon): Promise<Cart>;
-    removeCouponCode(payload: CartMutationRemoveCoupon): Promise<Cart>;
-    changeCurrency(payload: CartMutationChangeCurrency): Promise<Cart>;
+    getById(payload: CartQueryById): Promise<Result<Cart, NotFoundError>>;
+    add(payload: CartMutationItemAdd): Promise<Result<Cart>>;
+    remove(payload: CartMutationItemRemove): Promise<Result<Cart>>;
+    changeQuantity(payload: CartMutationItemQuantityChange): Promise<Result<Cart>>;
+    getActiveCartId(): Promise<Result<CartIdentifier, NotFoundError>>;
+    deleteCart(payload: CartMutationDeleteCart): Promise<Result<void>>;
+    applyCouponCode(payload: CartMutationApplyCoupon): Promise<Result<Cart>>;
+    removeCouponCode(payload: CartMutationRemoveCoupon): Promise<Result<Cart>>;
+    changeCurrency(payload: CartMutationChangeCurrency): Promise<Result<Cart>>;
     protected recalculateCart(cart: Cart): void;
+    protected createEmptyCart(): Cart;
 }

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

@@ -1,4 +1,4 @@
-import type { Category, CategoryPaginatedResult, CategoryQueryById, CategoryQueryBySlug, CategoryQueryForBreadcrumb, CategoryQueryForChildCategories, CategoryQueryForTopCategories, RequestContext } from "@reactionary/core";
+import type { Result, NotFoundError, 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";
@@ -6,13 +6,6 @@ import { Faker } from '@faker-js/faker';
 export declare class FakeCategoryProvider extends CategoryProvider {
     protected config: FakeConfiguration;
     protected topCategories: {
-        meta: {
-            cache: {
-                hit: boolean;
-                key: string;
-            };
-            placeholder: boolean;
-        };
         identifier: {
             key: string;
         };
@@ -30,13 +23,6 @@ export declare class FakeCategoryProvider extends CategoryProvider {
         } | undefined;
     }[];
     protected childCategories: Map<string, {
-        meta: {
-            cache: {
-                hit: boolean;
-                key: string;
-            };
-            placeholder: boolean;
-        };
         identifier: {
             key: string;
         };
@@ -54,13 +40,6 @@ export declare class FakeCategoryProvider extends CategoryProvider {
         } | undefined;
     }[]>;
     protected allCategories: Map<string, {
-        meta: {
-            cache: {
-                hit: boolean;
-                key: string;
-            };
-            placeholder: boolean;
-        };
         identifier: {
             key: string;
         };
@@ -80,9 +59,9 @@ export declare class FakeCategoryProvider extends CategoryProvider {
     protected categoryGenerator: Faker;
     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>;
+    getById(payload: CategoryQueryById): Promise<Result<Category, NotFoundError>>;
+    getBySlug(payload: CategoryQueryBySlug): Promise<Result<Category, NotFoundError>>;
+    getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb): Promise<Result<Category[]>>;
+    findChildCategories(payload: CategoryQueryForChildCategories): Promise<Result<CategoryPaginatedResult>>;
+    findTopCategories(payload: CategoryQueryForTopCategories): Promise<Result<CategoryPaginatedResult>>;
 }

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

@@ -1,11 +1,11 @@
-import { type Identity, type IdentityQuerySelf, type IdentityMutationLogin, type IdentityMutationLogout, type RequestContext, type Cache, IdentityProvider, type IdentityMutationRegister } from '@reactionary/core';
+import { type Identity, type IdentityQuerySelf, type IdentityMutationLogin, type IdentityMutationLogout, type RequestContext, type Cache, IdentityProvider, type IdentityMutationRegister, type Result } from '@reactionary/core';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
 export declare class FakeIdentityProvider extends IdentityProvider {
     protected config: FakeConfiguration;
     private currentIdentity;
     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>;
+    getSelf(_payload: IdentityQuerySelf): Promise<Result<Identity>>;
+    login(payload: IdentityMutationLogin): Promise<Result<Identity>>;
+    logout(_payload: IdentityMutationLogout): Promise<Result<Identity>>;
+    register(payload: IdentityMutationRegister): Promise<Result<Identity>>;
 }

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

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

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

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

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

@@ -1,14 +1,13 @@
 import { ProductSearchProvider } from '@reactionary/core';
-import type { ProductSearchResult, ProductSearchResultFacet, Cache as ReactionaryCache, FacetIdentifier, FacetValueIdentifier, ProductSearchResultFacetValue, ProductSearchResultItemVariant, ProductSearchQueryCreateNavigationFilter } from '@reactionary/core';
+import type { ProductSearchResult, ProductSearchResultFacet, Cache as ReactionaryCache, FacetIdentifier, FacetValueIdentifier, ProductSearchResultFacetValue, ProductSearchResultItemVariant, ProductSearchQueryCreateNavigationFilter, Result } from '@reactionary/core';
 import type { RequestContext, ProductSearchQueryByTerm } from '@reactionary/core';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
 export declare class FakeSearchProvider extends ProductSearchProvider {
     protected config: FakeConfiguration;
     constructor(config: FakeConfiguration, cache: ReactionaryCache, context: RequestContext);
-    createCategoryNavigationFilter(payload: ProductSearchQueryCreateNavigationFilter): Promise<FacetValueIdentifier>;
-    queryByTerm(payload: ProductSearchQueryByTerm): Promise<ProductSearchResult>;
+    createCategoryNavigationFilter(payload: ProductSearchQueryCreateNavigationFilter): Promise<Result<FacetValueIdentifier>>;
+    queryByTerm(payload: ProductSearchQueryByTerm): Promise<Result<ProductSearchResult>>;
     protected parseFacetValue(facetValueIdentifier: FacetValueIdentifier, label: string, count: number): ProductSearchResultFacetValue;
     protected parseFacet(facetIdentifier: FacetIdentifier, facetValue: unknown): ProductSearchResultFacet;
     protected parseVariant(variant: unknown, product: unknown): ProductSearchResultItemVariant;
-    protected childFunction(): number;
 }

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

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

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

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

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

@@ -2,11 +2,11 @@ import type { z } from 'zod';
 export declare const FakeCapabilitiesSchema: z.ZodObject<{
     price: z.ZodOptional<z.ZodBoolean>;
     product: z.ZodOptional<z.ZodBoolean>;
-    identity: z.ZodOptional<z.ZodBoolean>;
     cart: z.ZodOptional<z.ZodBoolean>;
-    productSearch: z.ZodOptional<z.ZodBoolean>;
+    identity: 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>;