@reactionary/source 0.6.1 → 0.6.3

package/{providers → packages}/fake/project.json

@@ -1,14 +1,13 @@
 {
   "name": "fake",
   "$schema": "../../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "providers/fake/src",
+  "sourceRoot": "packages/fake/src",
   "projectType": "library",
   "release": {
     "version": {
+      "manifestRootsToUpdate": ["dist/{projectRoot}"],
       "currentVersionResolver": "git-tag",
-      "fallbackCurrentVersionResolver": "disk",
-      "preserveLocalDependencyProtocols": false,
-      "manifestRootsToUpdate": ["dist/{projectRoot}"]
+      "fallbackCurrentVersionResolver": "disk"
     }
   },
   "tags": [],
@@ -17,10 +16,10 @@
       "executor": "@nx/esbuild:esbuild",
       "outputs": ["{options.outputPath}"],
       "options": {
-        "outputPath": "dist/providers/fake",
-        "main": "providers/fake/src/index.ts",
-        "tsConfig": "providers/fake/tsconfig.lib.json",
-        "assets": ["providers/fake/*.md"],
+        "outputPath": "dist/packages/fake",
+        "main": "packages/fake/src/index.ts",
+        "tsConfig": "packages/fake/tsconfig.lib.json",
+        "assets": ["packages/fake/*.md"],
         "format": ["esm"],
         "bundle": false
       }

package/{providers/fake/src/providers/analytics.provider.ts → packages/fake/src/capabilities/analytics.capability.ts}

@@ -3,12 +3,12 @@ import type {
   Cache,
   RequestContext} from '@reactionary/core';
 import {
-  AnalyticsProvider
+  AnalyticsCapability
 } from '@reactionary/core';
 import type * as z from 'zod';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
 
-export class FakeAnalyticsProvider extends AnalyticsProvider {
+export class FakeAnalyticsCapability extends AnalyticsCapability {
   protected config: FakeConfiguration;
 
   constructor(config: FakeConfiguration, cache: Cache, context: RequestContext) {

package/{providers/fake/src/providers/cart.provider.ts → packages/fake/src/capabilities/cart.capability.ts}

@@ -1,5 +1,8 @@
 import type {
   Cart,
+  CartFactory,
+  CartFactoryCartOutput,
+  CartFactoryWithOutput,
   CartQueryById,
   CartMutationItemAdd,
   CartMutationItemRemove,
@@ -23,7 +26,7 @@ import {
   CartMutationItemQuantityChangeSchema,
   CartMutationItemRemoveSchema,
   CartMutationRemoveCouponSchema,
-  CartProvider,
+  CartCapability,
   CartQueryByIdSchema,
   CartSchema,
   Reactionary,
@@ -33,16 +36,21 @@ import {
 } from '@reactionary/core';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
 import { Faker, en, base } from '@faker-js/faker';
+import type { FakeCartFactory } from '../factories/cart/cart.factory.js';
 
-export class FakeCartProvider extends CartProvider {
+export class FakeCartCapability<
+  TFactory extends CartFactory = FakeCartFactory,
+> extends CartCapability<CartFactoryCartOutput<TFactory>, CartIdentifier> {
   protected config: FakeConfiguration;
+  protected factory: CartFactoryWithOutput<TFactory>;
   private carts: Map<string, Cart> = new Map();
   private generator: Faker;
 
   constructor(
     config: FakeConfiguration,
     cache: Cache,
-    context: RequestContext
+    context: RequestContext,
+    factory: CartFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
     this.generator = new Faker({
@@ -50,6 +58,7 @@ export class FakeCartProvider extends CartProvider {
       seed: config.seeds.product,
     });
     this.config = config;
+    this.factory = factory;
   }
 
   @Reactionary({
@@ -58,7 +67,7 @@ export class FakeCartProvider extends CartProvider {
   })
   public override async getById(
     payload: CartQueryById
-  ): Promise<Result<Cart, NotFoundError>> {
+  ): Promise<Result<CartFactoryCartOutput<TFactory>, NotFoundError>> {
     const cartId = payload.cart.key;
 
     if (payload.cart.key === '') {
@@ -79,14 +88,14 @@ export class FakeCartProvider extends CartProvider {
     if (!cart) {
       throw new Error(`Cart with id ${cartId} not found`);
     }
-    return success(cart);
+    return success(this.factory.parseCart(this.context, cart));
   }
 
   @Reactionary({
     inputSchema: CartMutationItemAddSchema,
     outputSchema: CartSchema,
   })
-  public override async add(payload: CartMutationItemAdd): Promise<Result<Cart>> {
+  public override async add(payload: CartMutationItemAdd): Promise<Result<CartFactoryCartOutput<TFactory>>> {
     const cartId = payload?.cart?.key || `cart-${this.generator.string.uuid()}`;
     const cart = unwrapValue(await this.getById({ cart: { key: cartId } }));
 
@@ -133,14 +142,14 @@ export class FakeCartProvider extends CartProvider {
 
     this.recalculateCart(cart);
 
-    return success(cart);
+    return success(this.factory.parseCart(this.context, cart));
   }
 
   @Reactionary({
     inputSchema: CartMutationItemRemoveSchema,
     outputSchema: CartSchema,
   })
-  public override async remove(payload: CartMutationItemRemove): Promise<Result<Cart>> {
+  public override async remove(payload: CartMutationItemRemove): Promise<Result<CartFactoryCartOutput<TFactory>>> {
     const cartId = payload.cart.key || `cart-${this.generator.string.uuid()}`;
     const cart = unwrapValue(await this.getById({ cart: { key: cartId } }));
 
@@ -149,7 +158,7 @@ export class FakeCartProvider extends CartProvider {
     );
     this.recalculateCart(cart);
 
-    return success(cart);
+    return success(this.factory.parseCart(this.context, cart));
   }
 
   @Reactionary({
@@ -158,7 +167,7 @@ export class FakeCartProvider extends CartProvider {
   })
   public override async changeQuantity(
     payload: CartMutationItemQuantityChange
-  ): Promise<Result<Cart>> {
+  ): Promise<Result<CartFactoryCartOutput<TFactory>>> {
     const cartId = payload.cart.key || `cart-${this.generator.string.uuid()}`;
     const cart = unwrapValue(await this.getById({ cart: { key: cartId } }));
 
@@ -166,13 +175,13 @@ export class FakeCartProvider extends CartProvider {
       (item) => item.identifier.key === payload.item.key
     );
     if (payload.quantity < 1) {
-      return success(cart);
+      return success(this.factory.parseCart(this.context, cart));
     }
     if (item) {
       item.quantity = payload.quantity;
     }
     this.recalculateCart(cart);
-    return success(cart);
+    return success(this.factory.parseCart(this.context, cart));
   }
 
   @Reactionary({
@@ -196,7 +205,7 @@ export class FakeCartProvider extends CartProvider {
   })
   public override applyCouponCode(
     payload: CartMutationApplyCoupon
-  ): Promise<Result<Cart>> {
+  ): Promise<Result<CartFactoryCartOutput<TFactory>>> {
     throw new Error('Method not implemented.');
   }
 
@@ -206,7 +215,7 @@ export class FakeCartProvider extends CartProvider {
   })
   public override removeCouponCode(
     payload: CartMutationRemoveCoupon
-  ): Promise<Result<Cart>> {
+  ): Promise<Result<CartFactoryCartOutput<TFactory>>> {
     throw new Error('Method not implemented.');
   }
 
@@ -216,7 +225,7 @@ export class FakeCartProvider extends CartProvider {
   })
   public override changeCurrency(
     payload: CartMutationChangeCurrency
-  ): Promise<Result<Cart>> {
+  ): Promise<Result<CartFactoryCartOutput<TFactory>>> {
     throw new Error('Method not implemented.');
   }
 

package/packages/fake/src/capabilities/category.capability.ts

@@ -0,0 +1,199 @@
+import type {
+  Cache,
+  Category,
+  CategoryFactory,
+  CategoryFactoryCategoryOutput,
+  CategoryFactoryPaginatedOutput,
+  CategoryFactoryWithOutput,
+  CategoryPaginatedResult,
+  CategoryQueryById,
+  CategoryQueryBySlug,
+  CategoryQueryForBreadcrumb,
+  CategoryQueryForChildCategories,
+  CategoryQueryForTopCategories,
+  NotFoundError,
+  RequestContext,
+  Result,
+} from '@reactionary/core';
+import {
+  CategoryPaginatedResultSchema,
+  CategoryCapability,
+  CategoryQueryByIdSchema,
+  CategoryQueryBySlugSchema,
+  CategoryQueryForBreadcrumbSchema,
+  CategoryQueryForChildCategoriesSchema,
+  CategoryQueryForTopCategoriesSchema,
+  CategorySchema,
+  Reactionary,
+  error,
+  success,
+} from '@reactionary/core';
+import type { FakeConfiguration } from '../schema/configuration.schema.js';
+import * as z from 'zod';
+import { Faker, en, base } from '@faker-js/faker';
+import type { FakeCategoryFactory } from '../factories/category/category.factory.js';
+
+export class FakeCategoryCapability<
+  TFactory extends CategoryFactory = FakeCategoryFactory,
+> extends CategoryCapability<
+  CategoryFactoryCategoryOutput<TFactory>,
+  CategoryFactoryPaginatedOutput<TFactory>
+> {
+  protected config: FakeConfiguration;
+  protected factory: CategoryFactoryWithOutput<TFactory>;
+
+  protected topCategories: Category[] = [];
+  protected childCategories = new Map<string, Category[]>();
+  protected allCategories = new Map<string, Category>();
+
+  protected categoryGenerator: Faker;
+
+  protected generateFakeCategory(parent: Category | undefined, index: number): Category {
+    const name = parent
+      ? `${parent.name}-${index}`
+      : this.categoryGenerator.commerce.department();
+
+    const identifier = { key: name.toLowerCase().replace(/\s+/g, '-') };
+    const category = {
+      identifier,
+      images: [],
+      name,
+      slug: `${identifier.key}-slug`,
+      text: this.categoryGenerator.lorem.sentences(3),
+      parentCategory: parent?.identifier,
+    } satisfies Category;
+
+    this.allCategories.set(identifier.key, category);
+    return category;
+  }
+
+  constructor(
+    config: FakeConfiguration,
+    cache: Cache,
+    context: RequestContext,
+    factory: CategoryFactoryWithOutput<TFactory>,
+  ) {
+    super(cache, context);
+    this.config = config;
+    this.factory = factory;
+    this.categoryGenerator = new Faker({
+      seed: this.config.seeds.category,
+      locale: [en, base],
+    });
+
+    for (let i = 0; i < 6; i++) {
+      this.topCategories.push(this.generateFakeCategory(undefined, i));
+    }
+
+    this.topCategories.forEach((parentCategory) => {
+      const children: Category[] = [];
+      for (let j = 0; j < 5; j++) {
+        const childCategory = this.generateFakeCategory(parentCategory, j);
+        children.push(childCategory);
+
+        const subCategoryChildren: Category[] = [];
+        for (let k = 0; k < 5; k++) {
+          subCategoryChildren.push(this.generateFakeCategory(childCategory, k));
+        }
+        this.childCategories.set(childCategory.identifier.key, subCategoryChildren);
+      }
+      this.childCategories.set(parentCategory.identifier.key, children);
+    });
+  }
+
+  @Reactionary({
+    inputSchema: CategoryQueryByIdSchema,
+    outputSchema: CategorySchema,
+  })
+  public override async getById(
+    payload: CategoryQueryById,
+  ): Promise<Result<CategoryFactoryCategoryOutput<TFactory>, NotFoundError>> {
+    const category = this.allCategories.get(payload.id.key);
+
+    if (!category) {
+      return error<NotFoundError>({
+        type: 'NotFound',
+        identifier: payload,
+      });
+    }
+
+    return success(this.factory.parseCategory(this.context, category));
+  }
+
+  @Reactionary({
+    inputSchema: CategoryQueryBySlugSchema,
+    outputSchema: CategorySchema,
+  })
+  public override async getBySlug(
+    payload: CategoryQueryBySlug,
+  ): Promise<Result<CategoryFactoryCategoryOutput<TFactory>, NotFoundError>> {
+    for (const category of this.allCategories.values()) {
+      if (category.slug === payload.slug) {
+        return success(this.factory.parseCategory(this.context, category));
+      }
+    }
+
+    return error<NotFoundError>({
+      type: 'NotFound',
+      identifier: payload,
+    });
+  }
+
+  @Reactionary({
+    inputSchema: CategoryQueryForBreadcrumbSchema,
+    outputSchema: z.array(CategorySchema),
+  })
+  public override async getBreadcrumbPathToCategory(
+    payload: CategoryQueryForBreadcrumb,
+  ): Promise<Result<CategoryFactoryCategoryOutput<TFactory>[]>> {
+    const path: Category[] = [];
+    let next = this.allCategories.get(payload.id.key);
+
+    while (next) {
+      path.unshift(next);
+      if (!next.parentCategory) {
+        break;
+      }
+      next = this.allCategories.get(next.parentCategory.key);
+    }
+
+    return success(path.map((x) => this.factory.parseCategory(this.context, x)));
+  }
+
+  @Reactionary({
+    inputSchema: CategoryQueryForTopCategoriesSchema,
+    outputSchema: CategoryPaginatedResultSchema,
+  })
+  public override async findTopCategories(
+    _payload: CategoryQueryForTopCategories,
+  ): Promise<Result<CategoryFactoryPaginatedOutput<TFactory>>> {
+    const result = {
+      items: this.topCategories,
+      pageSize: this.topCategories.length,
+      pageNumber: 1,
+      totalCount: this.topCategories.length,
+      totalPages: 1,
+    } satisfies CategoryPaginatedResult;
+
+    return success(this.factory.parseCategoryPaginatedResult(this.context, result));
+  }
+
+  @Reactionary({
+    inputSchema: CategoryQueryForChildCategoriesSchema,
+    outputSchema: CategoryPaginatedResultSchema,
+  })
+  public override async findChildCategories(
+    payload: CategoryQueryForChildCategories,
+  ): Promise<Result<CategoryFactoryPaginatedOutput<TFactory>>> {
+    const items = this.childCategories.get(payload.parentId.key) || [];
+    const result = {
+      items,
+      pageSize: items.length,
+      pageNumber: 1,
+      totalCount: items.length,
+      totalPages: 1,
+    } satisfies CategoryPaginatedResult;
+
+    return success(this.factory.parseCategoryPaginatedResult(this.context, result));
+  }
+}

package/{providers/fake/src/providers/checkout.provider.ts → packages/fake/src/capabilities/checkout.capability.ts}

@@ -1,5 +1,5 @@
 import {
-  CheckoutProvider,
+  CheckoutCapability,
   type Checkout,
   type CheckoutMutationAddPaymentInstruction,
   type CheckoutMutationFinalizeCheckout,
@@ -29,21 +29,35 @@ import {
   CheckoutMutationFinalizeCheckoutSchema,
   success,
   type CheckoutIdentifier,
+  type CheckoutFactory,
+  type CheckoutFactoryCheckoutOutput,
+  type CheckoutFactoryPaymentMethodOutput,
+  type CheckoutFactoryShippingMethodOutput,
+  type CheckoutFactoryWithOutput,
   PaymentMethodSchema,
   ShippingMethodSchema,
 } from '@reactionary/core';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
 import { base, en, Faker } from '@faker-js/faker';
 import * as z from 'zod';
+import type { FakeCheckoutFactory } from '../factories/checkout/checkout.factory.js';
 
-export class FakeCheckoutProvider extends CheckoutProvider {
+export class FakeCheckoutCapability<
+  TFactory extends CheckoutFactory = FakeCheckoutFactory,
+> extends CheckoutCapability<
+  CheckoutFactoryCheckoutOutput<TFactory>,
+  CheckoutFactoryShippingMethodOutput<TFactory>,
+  CheckoutFactoryPaymentMethodOutput<TFactory>
+> {
   protected config: FakeConfiguration;
   protected generator: Faker;
+  protected factory: CheckoutFactoryWithOutput<TFactory>;
 
   constructor(
     config: FakeConfiguration,
     cache: Cache,
-    context: RequestContext
+    context: RequestContext,
+    factory: CheckoutFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
 
@@ -53,6 +67,7 @@ export class FakeCheckoutProvider extends CheckoutProvider {
       locale: [en, base],
       seed: config.seeds.product,
     });
+    this.factory = factory;
   }
 
   @Reactionary({
@@ -61,10 +76,10 @@ export class FakeCheckoutProvider extends CheckoutProvider {
   })
   public override async initiateCheckoutForCart(
     payload: CheckoutMutationInitiateCheckout
-  ): Promise<Result<Checkout>> {
+  ): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>> {
     const checkout = this.composeBaseCheckout(payload.cart.identifier);
 
-    return success(checkout);
+    return success(this.factory.parseCheckout(this.context, checkout));
   }
 
   @Reactionary({
@@ -73,10 +88,10 @@ export class FakeCheckoutProvider extends CheckoutProvider {
   })
   public override async getById(
     payload: CheckoutQueryById
-  ): Promise<Result<Checkout, NotFoundError>> {
+  ): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>, NotFoundError>> {
     const checkout = this.composeBaseCheckout(payload.identifier);
 
-    return success(checkout);
+    return success(this.factory.parseCheckout(this.context, checkout));
   }
 
   @Reactionary({
@@ -85,10 +100,10 @@ export class FakeCheckoutProvider extends CheckoutProvider {
   })
   public override async setShippingAddress(
     payload: CheckoutMutationSetShippingAddress
-  ): Promise<Result<Checkout>> {
+  ): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>> {
     const checkout = this.composeBaseCheckout(payload.checkout);
 
-    return success(checkout);
+    return success(this.factory.parseCheckout(this.context, checkout));
   }
 
   @Reactionary({
@@ -97,7 +112,7 @@ export class FakeCheckoutProvider extends CheckoutProvider {
   })
   public override async getAvailableShippingMethods(
     payload: CheckoutQueryForAvailableShippingMethods
-  ): Promise<Result<ShippingMethod[]>> {
+  ): Promise<Result<CheckoutFactoryShippingMethodOutput<TFactory>[]>> {
     const methods = [
       {
         name: 'Fake',
@@ -114,7 +129,9 @@ export class FakeCheckoutProvider extends CheckoutProvider {
       },
     ] satisfies Array<ShippingMethod>;
 
-    return success(methods);
+    return success(
+      methods.map((method) => this.factory.parseShippingMethod(this.context, method)),
+    );
   }
 
   @Reactionary({
@@ -123,7 +140,7 @@ export class FakeCheckoutProvider extends CheckoutProvider {
   })
   public override async getAvailablePaymentMethods(
     payload: CheckoutQueryForAvailablePaymentMethods
-  ): Promise<Result<PaymentMethod[]>> {
+  ): Promise<Result<CheckoutFactoryPaymentMethodOutput<TFactory>[]>> {
     const methods = [
       {
         description: 'A fake payment method for paying at some point',
@@ -136,7 +153,9 @@ export class FakeCheckoutProvider extends CheckoutProvider {
       },
     ] satisfies Array<PaymentMethod>;
 
-    return success(methods);
+    return success(
+      methods.map((method) => this.factory.parsePaymentMethod(this.context, method)),
+    );
   }
 
   @Reactionary({
@@ -145,10 +164,10 @@ export class FakeCheckoutProvider extends CheckoutProvider {
   })
   public override async addPaymentInstruction(
     payload: CheckoutMutationAddPaymentInstruction
-  ): Promise<Result<Checkout>> {
+  ): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>> {
     const checkout = this.composeBaseCheckout(payload.checkout);
 
-    return success(checkout);
+    return success(this.factory.parseCheckout(this.context, checkout));
   }
 
   @Reactionary({
@@ -157,10 +176,10 @@ export class FakeCheckoutProvider extends CheckoutProvider {
   })
   public override async removePaymentInstruction(
     payload: CheckoutMutationRemovePaymentInstruction
-  ): Promise<Result<Checkout>> {
+  ): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>> {
     const checkout = this.composeBaseCheckout(payload.checkout);
 
-    return success(checkout);
+    return success(this.factory.parseCheckout(this.context, checkout));
   }
 
   @Reactionary({
@@ -169,10 +188,10 @@ export class FakeCheckoutProvider extends CheckoutProvider {
   })
   public override async setShippingInstruction(
     payload: CheckoutMutationSetShippingInstruction
-  ): Promise<Result<Checkout>> {
+  ): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>> {
     const checkout = this.composeBaseCheckout(payload.checkout);
 
-    return success(checkout);
+    return success(this.factory.parseCheckout(this.context, checkout));
   }
 
   @Reactionary({
@@ -181,10 +200,10 @@ export class FakeCheckoutProvider extends CheckoutProvider {
   })
   public override async finalizeCheckout(
     payload: CheckoutMutationFinalizeCheckout
-  ): Promise<Result<Checkout>> {
+  ): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>> {
     const checkout = this.composeBaseCheckout(payload.checkout);
 
-    return success(checkout);
+    return success(this.factory.parseCheckout(this.context, checkout));
   }
 
   protected composeBaseCheckout(identifier?: CheckoutIdentifier) {