@reactionary/source 0.0.52 → 0.2.16

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

@@ -9,84 +9,93 @@ import type {
   CartIdentifier,
   CartMutationApplyCoupon,
   CartMutationChangeCurrency,
-  CartMutationCheckout,
   CartMutationDeleteCart,
   CartMutationRemoveCoupon,
-  CartMutationSetBillingAddress,
-  CartMutationSetShippingInfo,
-  OrderIdentifier} from '@reactionary/core';
+  Result,
+  NotFoundError
+} from '@reactionary/core';
 import {
-  CartProvider
+  CartIdentifierSchema,
+  CartMutationApplyCouponSchema,
+  CartMutationChangeCurrencySchema,
+  CartMutationDeleteCartSchema,
+  CartMutationItemAddSchema,
+  CartMutationItemQuantityChangeSchema,
+  CartMutationItemRemoveSchema,
+  CartMutationRemoveCouponSchema,
+  CartProvider,
+  CartQueryByIdSchema,
+  CartSchema,
+  Reactionary,
+  error,
+  success,
+  unwrapValue,
 } from '@reactionary/core';
-import type z from 'zod';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
 import { Faker, en, base } from '@faker-js/faker';
 
-export class FakeCartProvider<
-  T extends Cart = Cart
-> extends CartProvider<T> {
+export class FakeCartProvider extends CartProvider {
   protected config: FakeConfiguration;
-  private carts: Map<string, T> = new Map();
+  private carts: Map<string, Cart> = new Map();
   private generator: Faker;
 
-
-  constructor(config: FakeConfiguration, schema: z.ZodType<T>, cache: Cache) {
-    super(schema, cache);
+  constructor(
+    config: FakeConfiguration,
+    cache: Cache,
+    context: RequestContext
+  ) {
+    super(cache, context);
     this.generator = new Faker({
       locale: [en, base],
-      seed: config.seeds.product
+      seed: config.seeds.product,
     });
     this.config = config;
   }
 
+  @Reactionary({
+    inputSchema: CartQueryByIdSchema,
+    outputSchema: CartSchema,
+  })
   public override async getById(
-    payload: CartQueryById,
-    _reqCtx: RequestContext
-  ): Promise<T> {
+    payload: CartQueryById
+  ): Promise<Result<Cart, NotFoundError>> {
     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 error<NotFoundError>({
+        type: 'NotFound',
+        identifier: cartId,
+      });
     }
 
     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 cart = this.createEmptyCart();
+      cart.identifier.key = cartId;
+
+      this.carts.set(cartId, cart);
     }
 
     const cart = this.carts.get(cartId);
     if (!cart) {
       throw new Error(`Cart with id ${cartId} not found`);
     }
-    return cart;
+    return success(cart);
   }
 
-  public override async add(
-    payload: CartMutationItemAdd,
-    reqCtx: RequestContext
-  ): Promise<T> {
-
-    const cartId = payload.cart.key || `cart-${this.generator.string.uuid()}`;
-    const cart = await this.getById({ cart: { key: cartId } }, reqCtx);
+  @Reactionary({
+    inputSchema: CartMutationItemAddSchema,
+    outputSchema: CartSchema,
+  })
+  public override async add(payload: CartMutationItemAdd): Promise<Result<Cart>> {
+    const cartId = payload?.cart?.key || `cart-${this.generator.string.uuid()}`;
+    const cart = unwrapValue(await this.getById({ cart: { key: cartId } }));
 
+    if (cart.identifier.key === '') {
+      cart.identifier.key = cartId;
+      this.carts.set(cartId, cart);
+    }
     const existingItemIndex = cart.items.findIndex(
-      item => item.sku.key === payload.sku.key
+      (item) => item.variant.sku === payload.variant.sku
     );
 
     if (existingItemIndex >= 0) {
@@ -96,118 +105,180 @@ export class FakeCartProvider<
 
       cart.items.push({
         identifier: { key: `item-${Date.now()}` },
-        sku:  payload.sku,
+        variant: payload.variant,
         quantity: payload.quantity,
         price: {
           unitPrice: {
             value: price,
-            currency: reqCtx.languageContext.currencyCode,
+            currency: this.context.languageContext.currencyCode,
           },
           totalPrice: {
             value: 0, // Will be calculated below
-            currency: reqCtx.languageContext.currencyCode,
+            currency: this.context.languageContext.currencyCode,
           },
           totalDiscount: {
             value: 0,
-            currency: reqCtx.languageContext.currencyCode,
+            currency: this.context.languageContext.currencyCode,
           },
           unitDiscount: {
             value: 0,
-            currency: reqCtx.languageContext.currencyCode,
+            currency: this.context.languageContext.currencyCode,
           },
         },
         product: {
-          key: `product-for-${payload.sku.key}`,
+          key: `product-for-${payload.variant.sku}`,
         },
-
-
       });
     }
 
     this.recalculateCart(cart);
 
-    return this.assert(cart);
+    return success(cart);
   }
 
-  public override async remove(
-    payload: CartMutationItemRemove,
-    reqCtx: RequestContext
-  ): Promise<T> {
+  @Reactionary({
+    inputSchema: CartMutationItemRemoveSchema,
+    outputSchema: CartSchema,
+  })
+  public override async remove(payload: CartMutationItemRemove): Promise<Result<Cart>> {
     const cartId = payload.cart.key || `cart-${this.generator.string.uuid()}`;
-    const cart = await this.getById({ cart: { key: cartId } }, reqCtx);
+    const cart = unwrapValue(await this.getById({ cart: { key: cartId } }));
 
     cart.items = cart.items.filter(
-      item => item.identifier.key !== payload.item.key
+      (item) => item.identifier.key !== payload.item.key
     );
     this.recalculateCart(cart);
-    return this.assert(cart);
+
+    return success(cart);
   }
 
+  @Reactionary({
+    inputSchema: CartMutationItemQuantityChangeSchema,
+    outputSchema: CartSchema,
+  })
   public override async changeQuantity(
-    payload: CartMutationItemQuantityChange,
-    reqCtx: RequestContext
-  ): Promise<T> {
+    payload: CartMutationItemQuantityChange
+  ): Promise<Result<Cart>> {
     const cartId = payload.cart.key || `cart-${this.generator.string.uuid()}`;
-    const cart = await this.getById({ cart: { key: cartId } }, reqCtx);
+    const cart = unwrapValue(await this.getById({ cart: { key: cartId } }));
 
     const item = cart.items.find(
-      item => item.identifier.key === payload.item.key
+      (item) => item.identifier.key === payload.item.key
     );
     if (payload.quantity < 1) {
-      return cart;
+      return success(cart);
     }
     if (item) {
       item.quantity = payload.quantity;
     }
     this.recalculateCart(cart);
-    return this.assert(cart);
+    return success(cart);
   }
 
-
-  public override getActiveCartId(reqCtx: RequestContext): Promise<CartIdentifier> {
+  @Reactionary({
+    outputSchema: CartIdentifierSchema,
+  })
+  public override getActiveCartId(): Promise<Result<CartIdentifier, NotFoundError>> {
     throw new Error('Method not implemented.');
   }
-  public override deleteCart(payload: CartMutationDeleteCart, reqCtx: RequestContext): Promise<T> {
-    throw new Error('Method not implemented.');
-  }
-  public override setShippingInfo(payload: CartMutationSetShippingInfo, reqCtx: RequestContext): Promise<T> {
-    throw new Error('Method not implemented.');
-  }
-  public override setBillingAddress(payload: CartMutationSetBillingAddress, reqCtx: RequestContext): Promise<T> {
-    throw new Error('Method not implemented.');
-  }
-  public override applyCouponCode(payload: CartMutationApplyCoupon, reqCtx: RequestContext): Promise<T> {
+
+  @Reactionary({
+    inputSchema: CartMutationDeleteCartSchema,
+    outputSchema: CartSchema,
+  })
+  public override deleteCart(payload: CartMutationDeleteCart): Promise<Result<void>> {
     throw new Error('Method not implemented.');
   }
-  public override removeCouponCode(payload: CartMutationRemoveCoupon, reqCtx: RequestContext): Promise<T> {
+
+  @Reactionary({
+    inputSchema: CartMutationApplyCouponSchema,
+    outputSchema: CartSchema,
+  })
+  public override applyCouponCode(
+    payload: CartMutationApplyCoupon
+  ): Promise<Result<Cart>> {
     throw new Error('Method not implemented.');
   }
-  public override checkout(payload: CartMutationCheckout, reqCtx: RequestContext): Promise<OrderIdentifier> {
+
+  @Reactionary({
+    inputSchema: CartMutationRemoveCouponSchema,
+    outputSchema: CartSchema,
+  })
+  public override removeCouponCode(
+    payload: CartMutationRemoveCoupon
+  ): Promise<Result<Cart>> {
     throw new Error('Method not implemented.');
   }
-  public override changeCurrency(payload: CartMutationChangeCurrency, reqCtx: RequestContext): Promise<T> {
+
+  @Reactionary({
+    inputSchema: CartMutationChangeCurrencySchema,
+    outputSchema: CartSchema,
+  })
+  public override changeCurrency(
+    payload: CartMutationChangeCurrency
+  ): Promise<Result<Cart>> {
     throw new Error('Method not implemented.');
   }
 
-
-
-
-  protected recalculateCart(cart: T) {
-    cart.items.forEach(item => {
+  protected recalculateCart(cart: Cart) {
+    cart.items.forEach((item) => {
       item.price.totalPrice.value = item.price.unitPrice.value * item.quantity;
     });
 
     cart.price.totalProductPrice = {
-      value: cart.items.reduce((sum, item) => sum + item.price.totalPrice.value, 0),
+      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',
     };
   }
 
+  protected createEmptyCart(): Cart {
+    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: '',
+      },
+    } satisfies Cart;
 
-
+    return cart;
+  }
 }

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

@@ -1,23 +1,21 @@
-import type { Category, CategoryQueryById, CategoryQueryBySlug, CategoryQueryForBreadcrumb, CategoryQueryForChildCategories, CategoryQueryForTopCategories, RequestContext} from "@reactionary/core";
-import { CategoryProvider, Reactionary } from "@reactionary/core";
+import type { Result, NotFoundError, Category, CategoryPaginatedResult, CategoryQueryById, CategoryQueryBySlug, CategoryQueryForBreadcrumb, CategoryQueryForChildCategories, CategoryQueryForTopCategories, RequestContext} from "@reactionary/core";
+import { success, error, CategoryPaginatedResultSchema, CategoryProvider, CategoryQueryByIdSchema, CategoryQueryBySlugSchema, CategoryQueryForBreadcrumbSchema, CategoryQueryForChildCategoriesSchema, CategoryQueryForTopCategoriesSchema, CategorySchema, Reactionary } 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 z from "zod";
 import { Faker, en, base } from '@faker-js/faker';
-export class FakeCategoryProvider<
-  T extends Category = Category
-> extends CategoryProvider<T> {
+
+export class FakeCategoryProvider extends CategoryProvider {
 
   protected config: FakeConfiguration;
 
-  protected topCategories = new Array<T>();
-  protected childCategories = new Map<string, Array<T>>();
-  protected allCategories = new Map<string, T>();
+  protected topCategories = new Array<Category>();
+  protected childCategories = new Map<string, Array<Category>>();
+  protected allCategories = new Map<string, Category>();
 
   protected categoryGenerator: Faker;
 
-  protected generateFakeCategory(parent: Category | undefined, index: number): T {
-
+  protected generateFakeCategory(parent: Category | undefined, index: number): Category {
     let name: string;
     if (!parent) {
       name = this.categoryGenerator.commerce.department();
@@ -25,21 +23,31 @@ export class FakeCategoryProvider<
       name = `${parent.name}-${index}`;
     }
 
-    const category: T = 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: [],
+      name,
+      slug,
+      text,
+      parentCategory
+    } satisfies Category;
+
+    this.allCategories.set(identifier.key, category);
     return category;
   }
 
 
-  constructor(config: FakeConfiguration, schema: z.ZodType<T>, cache: ReactionaryCache) {
-    super(schema, cache);
+  constructor(config: FakeConfiguration, cache: ReactionaryCache, context: RequestContext) {
+    super(cache, context);
     this.config = config;
     this.categoryGenerator = new Faker({
       seed: this.config.seeds.category,
@@ -48,21 +56,21 @@ export class FakeCategoryProvider<
 
     // Generate some top-level categories
     for (let i = 0; i < 6; i++) {
-      const category: T = this.generateFakeCategory(undefined, i);
+      const category = this.generateFakeCategory(undefined, i);
       this.topCategories.push(category);
     }
 
     // Generate two levels of child categories
     this.topCategories.forEach((parentCategory) => {
-      const children = new Array<T>();
+      const children = new Array<Category>();
       for (let j = 0; j < 5; j++) {
-        const childCategory: T = this.generateFakeCategory(parentCategory, j);
+        const childCategory = this.generateFakeCategory(parentCategory, j);
         children.push(childCategory);
 
 
-        const subCategoryChildren = new Array<T>();
+        const subCategoryChildren = new Array<Category>();
         for(let k = 0; k < 5; k++) {
-          const subChildCategory: T = this.generateFakeCategory(childCategory, k);
+          const subChildCategory = this.generateFakeCategory(childCategory, k);
           subCategoryChildren.push(subChildCategory);
         }
         this.childCategories.set(childCategory.identifier.key, subCategoryChildren);
@@ -71,48 +79,64 @@ export class FakeCategoryProvider<
     });
   }
 
-  @Reactionary({})
-  public override async getById(payload: CategoryQueryById, reqCtx: RequestContext): Promise<T> {
+  @Reactionary({
+    inputSchema: CategoryQueryByIdSchema,
+    outputSchema: CategorySchema
+  })
+  public override async getById(payload: CategoryQueryById): Promise<Result<Category, NotFoundError>> {
     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;
+      return error<NotFoundError>({
+        type: 'NotFound',
+        identifier: payload
+      });
     }
-    return category;
+
+    return success(category);
   }
 
-  @Reactionary({})
-  public override getBySlug(payload: CategoryQueryBySlug, reqCtx: RequestContext): Promise<T | null> {
+  @Reactionary({
+    inputSchema: CategoryQueryBySlugSchema,
+    outputSchema: CategorySchema
+  })
+  public override async getBySlug(payload: CategoryQueryBySlug): Promise<Result<Category, NotFoundError>> {
     for(const p of this.allCategories.values()) {
       if(p.slug === payload.slug) {
-        return Promise.resolve(p as T);
+        return success(p);
       }
     }
-    return Promise.resolve(null);
+    return error<NotFoundError>({
+      type: 'NotFound',
+      identifier: payload
+    });
   }
 
-  @Reactionary({})
-  public override getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb, reqCtx: RequestContext): Promise<T[]> {
-    const path = new Array<T>();
+  @Reactionary({
+    inputSchema: CategoryQueryForBreadcrumbSchema,
+    outputSchema: z.array(CategorySchema)
+  })
+  public override async getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb): Promise<Result<Category[]>> {
+    const path = new Array<Category>();
     let category = this.allCategories.get(payload.id.key);
-    path.push(category as T);
+    path.push(category!);
     while(category?.parentCategory) {
       category = this.allCategories.get(category.parentCategory.key);
       if(category) {
-        path.unshift(category as T);
+        path.unshift(category);
       }
     }
-    return Promise.resolve(path);
+    return success(path);
   }
 
-  public override async findChildCategories(payload: CategoryQueryForChildCategories, reqCtx: RequestContext): Promise<ReturnType<typeof this.parsePaginatedResult>> {
+  @Reactionary({
+    inputSchema: CategoryQueryForChildCategoriesSchema,
+    outputSchema: CategoryPaginatedResultSchema
+  })
+  public override async findChildCategories(payload: CategoryQueryForChildCategories): Promise<Result<CategoryPaginatedResult>> {
     const children = this.childCategories.get(payload.parentId.key);
     const page = children?.slice((payload.paginationOptions.pageNumber - 1) * payload.paginationOptions.pageSize, payload.paginationOptions.pageNumber * payload.paginationOptions.pageSize);
 
-
     const res = {
       meta: {
         placeholder: false,
@@ -121,20 +145,24 @@ export class FakeCategoryProvider<
           key: 'child-categories-' + payload.parentId.key + '-' + payload.paginationOptions.pageNumber + '-' + payload.paginationOptions.pageSize,
         },
       },
-      items: page ? page as T[] : [],
+      items: page ? page : [],
       totalCount: children ? children.length : 0,
       pageNumber: payload.paginationOptions.pageNumber,
       pageSize: payload.paginationOptions.pageSize,
       totalPages: children ? Math.ceil(children.length / payload.paginationOptions.pageSize) : 1,
     };
 
-    return Promise.resolve(res);
+    return success(res);
   }
-  public override findTopCategories(payload: CategoryQueryForTopCategories, reqCtx: RequestContext): Promise<ReturnType<typeof this.parsePaginatedResult>> {
+
+  @Reactionary({
+    inputSchema: CategoryQueryForTopCategoriesSchema,
+    outputSchema: CategoryPaginatedResultSchema
+  })
+  public override async findTopCategories(payload: CategoryQueryForTopCategories): Promise<Result<CategoryPaginatedResult>> {
     const children = this.topCategories;
     const page = children?.slice((payload.paginationOptions.pageNumber - 1) * payload.paginationOptions.pageSize, payload.paginationOptions.pageNumber * payload.paginationOptions.pageSize);
 
-
     const res = {
       meta: {
         placeholder: false,
@@ -143,14 +171,14 @@ export class FakeCategoryProvider<
           key: 'top' + '-' + payload.paginationOptions.pageNumber + '-' + payload.paginationOptions.pageSize,
         },
       },
-      items: page ? page as T[] : [],
+      items: page ? page : [],
       totalCount: children ? children.length : 0,
       pageNumber: payload.paginationOptions.pageNumber,
       pageSize: payload.paginationOptions.pageSize,
       totalPages: children ? Math.ceil(children.length / payload.paginationOptions.pageSize) : 1,
     };
 
-    return Promise.resolve(res);
+    return success(res);
   }
 
 }