@reactionary/source 0.3.18 → 0.6.2

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

@@ -1,77 +1,99 @@
-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 * as z from "zod";
+import type {
+  Cache,
+  Category,
+  CategoryFactory,
+  CategoryFactoryCategoryOutput,
+  CategoryFactoryPaginatedOutput,
+  CategoryFactoryWithOutput,
+  CategoryPaginatedResult,
+  CategoryQueryById,
+  CategoryQueryBySlug,
+  CategoryQueryForBreadcrumb,
+  CategoryQueryForChildCategories,
+  CategoryQueryForTopCategories,
+  NotFoundError,
+  RequestContext,
+  Result,
+} from '@reactionary/core';
+import {
+  CategoryPaginatedResultSchema,
+  CategoryProvider,
+  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';
-
-export class FakeCategoryProvider extends CategoryProvider {
-
+import type { FakeCategoryFactory } from '../factories/category/category.factory.js';
+
+export class FakeCategoryProvider<
+  TFactory extends CategoryFactory = FakeCategoryFactory,
+> extends CategoryProvider<
+  CategoryFactoryCategoryOutput<TFactory>,
+  CategoryFactoryPaginatedOutput<TFactory>
+> {
   protected config: FakeConfiguration;
+  protected factory: CategoryFactoryWithOutput<TFactory>;
 
-  protected topCategories = new Array<Category>();
-  protected childCategories = new Map<string, Array<Category>>();
+  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 {
-    let name: string;
-    if (!parent) {
-      name = this.categoryGenerator.commerce.department();
-    } else {
-      name = `${parent.name}-${index}`;
-    }
+    const name = parent
+      ? `${parent.name}-${index}`
+      : this.categoryGenerator.commerce.department();
 
     const identifier = { key: name.toLowerCase().replace(/\s+/g, '-') };
-    const text = this.categoryGenerator.lorem.sentences(3);
-    const slug = identifier.key + '-slug';
-
-    let parentCategory;
-    if (parent) {
-      parentCategory = parent.identifier;
-    }
-
     const category = {
       identifier,
       images: [],
       name,
-      slug,
-      text,
-      parentCategory
+      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: ReactionaryCache, context: RequestContext) {
+  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],
     });
 
-    // Generate some top-level categories
     for (let i = 0; i < 6; i++) {
-      const category = this.generateFakeCategory(undefined, i);
-      this.topCategories.push(category);
+      this.topCategories.push(this.generateFakeCategory(undefined, i));
     }
 
-    // Generate two levels of child categories
     this.topCategories.forEach((parentCategory) => {
-      const children = new Array<Category>();
+      const children: Category[] = [];
       for (let j = 0; j < 5; j++) {
         const childCategory = this.generateFakeCategory(parentCategory, j);
         children.push(childCategory);
 
-
-        const subCategoryChildren = new Array<Category>();
-        for(let k = 0; k < 5; k++) {
-          const subChildCategory = this.generateFakeCategory(childCategory, k);
-          subCategoryChildren.push(subChildCategory);
+        const subCategoryChildren: Category[] = [];
+        for (let k = 0; k < 5; k++) {
+          subCategoryChildren.push(this.generateFakeCategory(childCategory, k));
         }
         this.childCategories.set(childCategory.identifier.key, subCategoryChildren);
       }
@@ -81,104 +103,97 @@ export class FakeCategoryProvider extends CategoryProvider {
 
   @Reactionary({
     inputSchema: CategoryQueryByIdSchema,
-    outputSchema: CategorySchema
+    outputSchema: CategorySchema,
   })
-  public override async getById(payload: CategoryQueryById): Promise<Result<Category, NotFoundError>> {
+  public override async getById(
+    payload: CategoryQueryById,
+  ): Promise<Result<CategoryFactoryCategoryOutput<TFactory>, NotFoundError>> {
     const category = this.allCategories.get(payload.id.key);
 
-    if(!category) {
+    if (!category) {
       return error<NotFoundError>({
         type: 'NotFound',
-        identifier: payload
+        identifier: payload,
       });
     }
 
-    return success(category);
+    return success(this.factory.parseCategory(this.context, category));
   }
 
   @Reactionary({
     inputSchema: CategoryQueryBySlugSchema,
-    outputSchema: CategorySchema
+    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 success(p);
+  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
+      identifier: payload,
     });
   }
 
   @Reactionary({
     inputSchema: CategoryQueryForBreadcrumbSchema,
-    outputSchema: z.array(CategorySchema)
+    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!);
-    while(category?.parentCategory) {
-      category = this.allCategories.get(category.parentCategory.key);
-      if(category) {
-        path.unshift(category);
+  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);
+
+    return success(path.map((x) => this.factory.parseCategory(this.context, x)));
   }
 
   @Reactionary({
-    inputSchema: CategoryQueryForChildCategoriesSchema,
-    outputSchema: CategoryPaginatedResultSchema
+    inputSchema: CategoryQueryForTopCategoriesSchema,
+    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,
-        cache: {
-          hit: false,
-          key: 'child-categories-' + payload.parentId.key + '-' + payload.paginationOptions.pageNumber + '-' + payload.paginationOptions.pageSize,
-        },
-      },
-      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 success(res);
+  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: CategoryQueryForTopCategoriesSchema,
-    outputSchema: CategoryPaginatedResultSchema
+    inputSchema: CategoryQueryForChildCategoriesSchema,
+    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,
-        cache: {
-          hit: false,
-          key: 'top' + '-' + payload.paginationOptions.pageNumber + '-' + payload.paginationOptions.pageSize,
-        },
-      },
-      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 success(res);
+  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

@@ -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 FakeCheckoutProvider<
+  TFactory extends CheckoutFactory = FakeCheckoutFactory,
+> extends CheckoutProvider<
+  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) {

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

@@ -1,102 +1,108 @@
 import {
+  type AnonymousIdentity,
+  type Cache,
   type Identity,
-  type IdentityQuerySelf,
+  type IdentityFactory,
+  type IdentityFactoryOutput,
+  type IdentityFactoryWithOutput,
   type IdentityMutationLogin,
+  IdentityMutationLoginSchema,
   type IdentityMutationLogout,
-  type RequestContext,
-  type Cache,
-  IdentityProvider,
+  IdentityMutationLogoutSchema,
   type IdentityMutationRegister,
-  type AnonymousIdentity,
-  type RegisteredIdentity,
-  Reactionary,
   IdentityMutationRegisterSchema,
-  IdentitySchema,
-  IdentityMutationLogoutSchema,
-  IdentityMutationLoginSchema,
+  type IdentityQuerySelf,
   IdentityQuerySelfSchema,
+  IdentityProvider,
+  IdentitySchema,
+  type RegisteredIdentity,
+  type RequestContext,
   type Result,
+  Reactionary,
   success,
 } from '@reactionary/core';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
 import { base, en, Faker } from '@faker-js/faker';
+import type { FakeIdentityFactory } from '../factories/identity/identity.factory.js';
 
-export class FakeIdentityProvider extends IdentityProvider {
+export class FakeIdentityProvider<
+  TFactory extends IdentityFactory = FakeIdentityFactory,
+> extends IdentityProvider<IdentityFactoryOutput<TFactory>> {
   protected config: FakeConfiguration;
+  protected factory: IdentityFactoryWithOutput<TFactory>;
   private currentIdentity: Identity | null = null;
 
   constructor(
     config: FakeConfiguration,
     cache: Cache,
-    context: RequestContext
+    context: RequestContext,
+    factory: IdentityFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
 
     this.config = config;
+    this.factory = factory;
   }
 
   @Reactionary({
     inputSchema: IdentityQuerySelfSchema,
-    outputSchema: IdentitySchema
+    outputSchema: IdentitySchema,
   })
   public override async getSelf(
-    _payload: IdentityQuerySelf
-  ): Promise<Result<Identity>> {
+    _payload: IdentityQuerySelf,
+  ): Promise<Result<IdentityFactoryOutput<TFactory>>> {
     if (!this.currentIdentity) {
-      const model = {
+      this.currentIdentity = {
         type: 'Anonymous',
       } satisfies AnonymousIdentity;
-
-      this.currentIdentity = model;
     }
 
-    return success(this.currentIdentity);
+    return success(this.factory.parseIdentity(this.context, this.currentIdentity));
   }
 
   @Reactionary({
     inputSchema: IdentityMutationLoginSchema,
-    outputSchema: IdentitySchema
+    outputSchema: IdentitySchema,
   })
   public override async login(
-    payload: IdentityMutationLogin
-  ): Promise<Result<Identity>> {
+    _payload: IdentityMutationLogin,
+  ): Promise<Result<IdentityFactoryOutput<TFactory>>> {
     const generator = new Faker({
       seed: 42,
       locale: [en, base],
     });
 
-    const model = {
+    this.currentIdentity = {
       type: 'Registered',
       id: {
         userId: generator.string.alphanumeric(32),
       },
     } satisfies RegisteredIdentity;
 
-    this.currentIdentity = model;
-
-    return success(this.currentIdentity);
+    return success(this.factory.parseIdentity(this.context, this.currentIdentity));
   }
 
   @Reactionary({
     inputSchema: IdentityMutationLogoutSchema,
-    outputSchema: IdentitySchema
+    outputSchema: IdentitySchema,
   })
   public override async logout(
-    _payload: IdentityMutationLogout
-  ): Promise<Result<Identity>> {
-    const model = {
+    _payload: IdentityMutationLogout,
+  ): Promise<Result<IdentityFactoryOutput<TFactory>>> {
+    this.currentIdentity = {
       type: 'Anonymous',
     } satisfies AnonymousIdentity;
 
-    this.currentIdentity = model;
-    return success(this.currentIdentity);
+    return success(this.factory.parseIdentity(this.context, this.currentIdentity));
   }
 
   @Reactionary({
     inputSchema: IdentityMutationRegisterSchema,
-    outputSchema: IdentitySchema
+    outputSchema: IdentitySchema,
   })
-  public override register(payload: IdentityMutationRegister): Promise<Result<Identity>> {
+  public override register(
+    _payload: IdentityMutationRegister,
+  ): Promise<Result<IdentityFactoryOutput<TFactory>>> {
     throw new Error('Method not implemented.');
   }
 }