@reactionary/source 0.6.1 → 0.6.3

package/{providers/fake/src/providers/product-associations.provider.ts → packages/fake/src/capabilities/product-associations.capability.ts}

@@ -1,5 +1,5 @@
 import {
-  ProductAssociationsProvider,
+  ProductAssociationsCapability,
   Reactionary,
   type ProductAssociationsGetAccessoriesQuery,
   type ProductAssociationsGetSparepartsQuery,
@@ -7,23 +7,36 @@ import {
   type Result,
   success,
   type ProductAssociation,
+  type Cache,
   type ProductSearchResultItem,
+  type RequestContext,
+} from '@reactionary/core';
+import type {
+  ProductAssociationsFactory,
+  ProductAssociationsFactoryOutput,
+  ProductAssociationsFactoryWithOutput,
 } from '@reactionary/core';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
-import { base, en, Faker } from '@faker-js/faker';
+import { en, Faker } from '@faker-js/faker';
 import { calcSeed } from '../utilities/seed.js';
+import type { FakeProductAssociationsFactory } from '../factories/product-associations/product-associations.factory.js';
 
-export class FakeProductAssociationsProvider extends ProductAssociationsProvider {
+export class FakeProductAssociationsCapability<
+  TFactory extends ProductAssociationsFactory = FakeProductAssociationsFactory,
+> extends ProductAssociationsCapability<ProductAssociationsFactoryOutput<TFactory>> {
   protected config: FakeConfiguration;
+  protected factory: ProductAssociationsFactoryWithOutput<TFactory>;
   protected faker: Faker;
 
   constructor(
     config: FakeConfiguration,
-    cache: any,
-    context: any
+    cache: Cache,
+    context: RequestContext,
+    factory: ProductAssociationsFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
     this.config = config;
+    this.factory = factory;
     this.faker = new Faker({ locale: [en] });
   }
 
@@ -35,7 +48,7 @@ export class FakeProductAssociationsProvider extends ProductAssociationsProvider
   })
   public override async getAccessories(
     query: ProductAssociationsGetAccessoriesQuery
-  ): Promise<Result<ProductAssociation[]>> {
+  ): Promise<Result<ProductAssociationsFactoryOutput<TFactory>[]>> {
     const associatedProducts = this.generateFakeAssociatedProducts(query.forProduct.key, query.numberOfAccessories || 4, 'accessory');
 
     const result: ProductAssociation[] = associatedProducts.map(product => ({
@@ -46,7 +59,7 @@ export class FakeProductAssociationsProvider extends ProductAssociationsProvider
       product,
     } satisfies ProductAssociation));
 
-    return success(result);
+    return success(result.map((x) => this.factory.parseAssociation(this.context, x)));
   }
 
   @Reactionary({
@@ -57,7 +70,7 @@ export class FakeProductAssociationsProvider extends ProductAssociationsProvider
   })
   public override async getSpareparts(
     query: ProductAssociationsGetSparepartsQuery
-  ): Promise<Result<ProductAssociation[]>> {
+  ): Promise<Result<ProductAssociationsFactoryOutput<TFactory>[]>> {
     const associatedProducts = this.generateFakeAssociatedProducts(query.forProduct.key, query.numberOfSpareparts || 4, 'sparepart');
 
     const result: ProductAssociation[] = associatedProducts.map(product => ({
@@ -68,7 +81,7 @@ export class FakeProductAssociationsProvider extends ProductAssociationsProvider
       product,
     } satisfies ProductAssociation));
 
-    return success(result);
+    return success(result.map((x) => this.factory.parseAssociation(this.context, x)));
   }
 
   @Reactionary({
@@ -79,7 +92,7 @@ export class FakeProductAssociationsProvider extends ProductAssociationsProvider
   })
   public override async getReplacements(
     query: ProductAssociationsGetReplacementsQuery
-  ): Promise<Result<ProductAssociation[]>> {
+  ): Promise<Result<ProductAssociationsFactoryOutput<TFactory>[]>> {
     const associatedProducts = this.generateFakeAssociatedProducts(query.forProduct.key, query.numberOfReplacements || 4, 'replacement');
 
     const result: ProductAssociation[] = associatedProducts.map(product => ({
@@ -90,7 +103,7 @@ export class FakeProductAssociationsProvider extends ProductAssociationsProvider
       product,
     } satisfies ProductAssociation));
 
-    return success(result);
+    return success(result.map((x) => this.factory.parseAssociation(this.context, x)));
   }
 
   private generateFakeAssociatedProducts(baseProductKey: string, count: number, type: string): ProductSearchResultItem[] {

package/{providers/fake/src/providers/product-reviews.provider.ts → packages/fake/src/capabilities/product-reviews.capability.ts}

@@ -1,54 +1,61 @@
 import {
-  ProductReviewsProvider,
-  Reactionary,
-  success,
-  error,
-  ProductReviewSchema,
   ProductRatingSummarySchema,
   ProductReviewPaginatedResultSchema,
-} from '@reactionary/core';
-import type {
-  ProductReview,
-  ProductRatingSummary,
-  ProductReviewPaginatedResult,
-  ProductReviewsListQuery,
-  ProductReviewsGetRatingSummaryQuery,
-  ProductReviewMutationSubmit,
-  Result,
-  RequestContext,
-  Cache,
-  NotFoundError,
-  InvalidInputError,
-  ProductIdentifier,
+  ProductReviewSchema,
+  ProductReviewsCapability,
+  Reactionary,
+  error,
+  success,
+  type Cache,
+  type InvalidInputError,
+  type ProductIdentifier,
+  type ProductRatingSummary,
+  type ProductReviewsFactory,
+  type ProductReviewsFactoryRatingOutput,
+  type ProductReviewsFactoryReviewOutput,
+  type ProductReviewsFactoryReviewPaginatedOutput,
+  type ProductReviewsFactoryWithOutput,
+  type ProductReviewsGetRatingSummaryQuery,
+  type ProductReviewsListQuery,
+  type ProductReview,
+  type ProductReviewMutationSubmit,
+  type RequestContext,
+  type Result,
 } from '@reactionary/core';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
 import { base, en, Faker } from '@faker-js/faker';
 import { calcSeed } from '../utilities/seed.js';
-
-export class FakeProductReviewsProvider extends ProductReviewsProvider {
+import type { FakeProductReviewsFactory } from '../factories/product-reviews/product-reviews.factory.js';
+
+export class FakeProductReviewsCapability<
+  TFactory extends ProductReviewsFactory = FakeProductReviewsFactory,
+> extends ProductReviewsCapability<
+  ProductReviewsFactoryRatingOutput<TFactory>,
+  ProductReviewsFactoryReviewPaginatedOutput<TFactory>,
+  ProductReviewsFactoryReviewOutput<TFactory>
+> {
   protected config: FakeConfiguration;
+  protected factory: ProductReviewsFactoryWithOutput<TFactory>;
   private faker: Faker;
 
   constructor(
     config: FakeConfiguration,
     cache: Cache,
-    context: RequestContext
+    context: RequestContext,
+    factory: ProductReviewsFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
     this.config = config;
-    this.faker = new Faker({ locale: [en] });
+    this.factory = factory;
+    this.faker = new Faker({ locale: [en, base] });
   }
 
   protected createReviewsForProduct(productIdentifier: ProductIdentifier): ProductReview[] {
     const seed = calcSeed(productIdentifier.key);
-    this.faker.seed(seed); // Seed faker with product key for consistent results
-
-    const hasAnyReviews = this.faker.datatype.boolean({ probability: 0.5 }); // 50% chance that the product has reviews
-    if (!hasAnyReviews) {
-      return [];
-    }
+    this.faker.seed(seed);
 
-    if (productIdentifier.key === 'unknown-product-id') {
+    const hasAnyReviews = this.faker.datatype.boolean({ probability: 0.5 });
+    if (!hasAnyReviews || productIdentifier.key === 'unknown-product-id') {
       return [];
     }
 
@@ -56,9 +63,9 @@ export class FakeProductReviewsProvider extends ProductReviewsProvider {
     const totalReviews = this.faker.number.int({ min: 1, max: 20 });
 
     for (let i = 0; i < totalReviews; i++) {
-      const hasReply = this.faker.datatype.boolean({ probability: 0.3 }); // 30% chance that the review has a reply
+      const hasReply = this.faker.datatype.boolean({ probability: 0.3 });
 
-      const review = {
+      reviews.push({
         identifier: {
           key: `fake-review-${productIdentifier.key}-${i}`,
         },
@@ -69,48 +76,38 @@ export class FakeProductReviewsProvider extends ProductReviewsProvider {
         title: this.faker.lorem.sentence(),
         content: this.faker.lorem.paragraphs({ min: 1, max: 5 }),
         createdAt: this.faker.date.past({ years: 1 }).toISOString(),
-        updatedAt: this.faker.datatype.boolean() ? this.faker.date.recent({ days: 30 }).toISOString() : undefined,
+        updatedAt: this.faker.datatype.boolean()
+          ? this.faker.date.recent({ days: 30 }).toISOString()
+          : undefined,
         verified: this.faker.datatype.boolean(),
         reply: hasReply ? this.faker.lorem.sentences(2) : undefined,
         repliedAt: hasReply ? this.faker.date.recent({ days: 7 }).toISOString() : undefined,
-
-      } satisfies ProductReview;
-
-      reviews.push(review);
+      });
     }
 
-    return reviews.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()); // Sort reviews by created date descending
+    return reviews.sort(
+      (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime(),
+    );
   }
 
-
   @Reactionary({
     outputSchema: ProductRatingSummarySchema,
     cache: true,
     cacheTimeToLiveInSeconds: 300,
     currencyDependentCaching: false,
-    localeDependentCaching: false
+    localeDependentCaching: false,
   })
   public override async getRatingSummary(
-    query: ProductReviewsGetRatingSummaryQuery
-  ): Promise<Result<ProductRatingSummary>> {
-
+    query: ProductReviewsGetRatingSummaryQuery,
+  ): Promise<Result<ProductReviewsFactoryRatingOutput<TFactory>>> {
     const reviews = this.createReviewsForProduct(query.product);
     if (reviews.length === 0) {
-      // If there are no reviews, return a summary with averageRating 0 and totalRatings 0
       const emptySummary = this.createEmptyProductRatingSummary({ product: query.product });
-      return success(emptySummary);
+      return success(this.factory.parseRatingSummary(this.context, emptySummary));
     }
 
     const totalRatings = reviews.length;
-    const averageRating = reviews.reduce((sum, review) => sum + review.rating, 0) / (totalRatings || 1);
-
-    const ratingDistribution = {
-      '1': reviews.filter(x => x.rating === 1).length,
-      '2': reviews.filter(x => x.rating === 2).length,
-      '3': reviews.filter(x => x.rating === 3).length,
-      '4': reviews.filter(x => x.rating === 4).length,
-      '5': reviews.filter(x => x.rating === 5).length,
-    };
+    const averageRating = reviews.reduce((sum, review) => sum + review.rating, 0) / totalRatings;
 
     const summary: ProductRatingSummary = {
       identifier: {
@@ -118,10 +115,16 @@ export class FakeProductReviewsProvider extends ProductReviewsProvider {
       },
       averageRating,
       totalRatings,
-      ratingDistribution,
+      ratingDistribution: {
+        '1': reviews.filter((x) => x.rating === 1).length,
+        '2': reviews.filter((x) => x.rating === 2).length,
+        '3': reviews.filter((x) => x.rating === 3).length,
+        '4': reviews.filter((x) => x.rating === 4).length,
+        '5': reviews.filter((x) => x.rating === 5).length,
+      },
     };
 
-    return success(summary);
+    return success(this.factory.parseRatingSummary(this.context, summary));
   }
 
   @Reactionary({
@@ -129,19 +132,18 @@ export class FakeProductReviewsProvider extends ProductReviewsProvider {
     cache: true,
     cacheTimeToLiveInSeconds: 60,
     currencyDependentCaching: false,
-    localeDependentCaching: true
+    localeDependentCaching: true,
   })
   public override async findReviews(
-    query: ProductReviewsListQuery
-  ): Promise<Result<ProductReviewPaginatedResult>> {
+    query: ProductReviewsListQuery,
+  ): Promise<Result<ProductReviewsFactoryReviewPaginatedOutput<TFactory>>> {
     const pageSize = query.paginationOptions?.pageSize ?? 20;
     const pageNumber = query.paginationOptions?.pageNumber ?? 1;
 
     const reviews = this.createReviewsForProduct(query.product);
-
     const returnedReviews = reviews.slice((pageNumber - 1) * pageSize, pageNumber * pageSize);
 
-    const paginatedResult: ProductReviewPaginatedResult = {
+    const result = {
       items: returnedReviews,
       totalCount: reviews.length,
       pageSize,
@@ -149,7 +151,7 @@ export class FakeProductReviewsProvider extends ProductReviewsProvider {
       totalPages: Math.ceil(reviews.length / Math.max(pageSize, 1)),
     };
 
-    return success(paginatedResult);
+    return success(this.factory.parseReviewPaginatedResult(this.context, result));
   }
 
   @Reactionary({
@@ -157,18 +159,18 @@ export class FakeProductReviewsProvider extends ProductReviewsProvider {
     cache: false,
     cacheTimeToLiveInSeconds: 0,
     currencyDependentCaching: false,
-    localeDependentCaching: false
+    localeDependentCaching: false,
   })
   public override async submitReview(
-    mutation: ProductReviewMutationSubmit
-  ): Promise<Result<ProductReview>> {
-    // For fake provider, we always succeed and return a fake review
-
+    mutation: ProductReviewMutationSubmit,
+  ): Promise<Result<ProductReviewsFactoryReviewOutput<TFactory>>> {
     if (this.context.session.identityContext.identity.type !== 'Registered') {
-      return error<InvalidInputError>({ type: 'InvalidInput', error: 'Only registered users can submit reviews.' });
+      return error<InvalidInputError>({
+        type: 'InvalidInput',
+        error: 'Only registered users can submit reviews.',
+      });
     }
 
-
     const review: ProductReview = {
       identifier: {
         key: this.faker.string.uuid(),
@@ -182,6 +184,6 @@ export class FakeProductReviewsProvider extends ProductReviewsProvider {
       verified: this.faker.datatype.boolean(),
     };
 
-    return success(review);
+    return success(this.factory.parseReview(this.context, review));
   }
 }

package/{providers/fake/src/providers/product-search.provider.ts → packages/fake/src/capabilities/product-search.capability.ts}

@@ -1,45 +1,47 @@
 import {
   ImageSchema,
-  ProductSearchProvider,
+  ProductSearchCapability,
   ProductSearchQueryByTermSchema,
   ProductSearchResultItemSchema,
   ProductSearchResultSchema,
   Reactionary,
   success,
-  error,
-} from '@reactionary/core';
-import type {
-  ProductSearchResult,
-  ProductSearchResultFacet,
-  ProductSearchResultItem,
-  Cache as ReactionaryCache,
-  Image,
-  FacetIdentifier,
-  FacetValueIdentifier,
-  ProductSearchResultFacetValue,
-  ProductSearchResultItemVariant,
-  ProductSearchQueryCreateNavigationFilter,
-  Result,
-} from '@reactionary/core';
-import type {
-  RequestContext,
-  ProductSearchQueryByTerm,
+  type Cache,
+  type FacetIdentifier,
+  type FacetValueIdentifier,
+  type ProductSearchFactory,
+  type ProductSearchFactoryOutput,
+  type ProductSearchFactoryWithOutput,
+  type ProductSearchQueryByTerm,
+  type ProductSearchQueryCreateNavigationFilter,
+  type ProductSearchResult,
+  type ProductSearchResultFacet,
+  type ProductSearchResultItem,
+  type ProductSearchResultItemVariant,
+  type RequestContext,
+  type Result,
 } from '@reactionary/core';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
 import { Faker, en, base } from '@faker-js/faker';
 import { jitter } from '../utilities/jitter.js';
+import type { FakeProductSearchFactory } from '../factories/product-search/product-search.factory.js';
 
-export class FakeSearchProvider extends ProductSearchProvider {
+export class FakeProductSearchCapability<
+  TFactory extends ProductSearchFactory = FakeProductSearchFactory,
+> extends ProductSearchCapability<ProductSearchFactoryOutput<TFactory>> {
   protected config: FakeConfiguration;
+  protected factory: ProductSearchFactoryWithOutput<TFactory>;
 
   constructor(
     config: FakeConfiguration,
-    cache: ReactionaryCache,
-    context: RequestContext
+    cache: Cache,
+    context: RequestContext,
+    factory: ProductSearchFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
 
     this.config = config;
+    this.factory = factory;
   }
 
   @Reactionary({
@@ -47,25 +49,17 @@ export class FakeSearchProvider extends ProductSearchProvider {
     outputSchema: ProductSearchResultSchema,
   })
   public override async queryByTerm(
-    payload: ProductSearchQueryByTerm
-  ): Promise<Result<ProductSearchResult>> {
+    payload: ProductSearchQueryByTerm,
+  ): Promise<Result<ProductSearchFactoryOutput<TFactory>>> {
     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;
+      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,
@@ -77,8 +71,8 @@ export class FakeSearchProvider extends ProductSearchProvider {
       locale: [en, base],
     });
 
-    const products = new Array<ProductSearchResultItem>();
-    const facets = new Array<ProductSearchResultFacet>();
+    const products: ProductSearchResultItem[] = [];
+    const facets: ProductSearchResultFacet[] = [];
 
     for (let i = 0; i < productsOnPage; i++) {
       const srcUrl = productGenerator.image.urlPicsumPhotos({
@@ -93,12 +87,12 @@ export class FakeSearchProvider extends ProductSearchProvider {
         altText: 'Fake product image',
         height: 300,
         width: 300,
-      } satisfies Partial<Image>);
+      });
 
       products.push(
         ProductSearchResultItemSchema.parse({
           identifier: {
-            key: 'product_' + productGenerator.commerce.isbn(),
+            key: `product_${productGenerator.commerce.isbn()}`,
           },
           name: productGenerator.commerce.productName(),
           slug: productGenerator.lorem.slug(),
@@ -111,18 +105,16 @@ export class FakeSearchProvider extends ProductSearchProvider {
               options: undefined,
             } satisfies Partial<ProductSearchResultItemVariant>,
           ],
-        } satisfies Partial<ProductSearchResultItem>)
+        }),
       );
     }
 
-    const facetBase = ['color', 'size'];
-
-    for (const base of facetBase) {
+    for (const baseFacet of ['color', 'size']) {
       const facet: ProductSearchResultFacet = {
         identifier: {
-          key: base,
+          key: baseFacet,
         },
-        name: base,
+        name: baseFacet,
         values: [],
       };
 
@@ -130,7 +122,7 @@ export class FakeSearchProvider extends ProductSearchProvider {
         const valueKey = i.toString();
         const isActive =
           query.facets.find(
-            (x) => x.facet.key === facet.identifier.key && x.key === valueKey
+            (x) => x.facet.key === facet.identifier.key && x.key === valueKey,
           ) !== undefined;
 
         facet.values.push({
@@ -149,7 +141,7 @@ export class FakeSearchProvider extends ProductSearchProvider {
       facets.push(facet);
     }
 
-    const result = ProductSearchResultSchema.parse({
+    const result = {
       identifier: {
         term: query.term,
         paginationOptions: {
@@ -159,19 +151,19 @@ export class FakeSearchProvider extends ProductSearchProvider {
         facets: query.facets,
         filters: [],
       },
-      facets: facets,
+      facets,
       items: products,
       pageNumber: query.paginationOptions.pageNumber,
       pageSize: query.paginationOptions.pageSize,
       totalCount: totalProducts,
-      totalPages: totalPages,
-    } satisfies ProductSearchResult);
+      totalPages,
+    } satisfies ProductSearchResult;
 
-    return success(result);
+    return success(this.factory.parseSearchResult(this.context, result, payload));
   }
 
   public override async createCategoryNavigationFilter(
-    payload: ProductSearchQueryCreateNavigationFilter
+    payload: ProductSearchQueryCreateNavigationFilter,
   ): Promise<Result<FacetValueIdentifier>> {
     const facetIdentifier = {
       key: 'category',
@@ -184,23 +176,4 @@ export class FakeSearchProvider extends ProductSearchProvider {
     return success(facetValueIdentifier);
   }
 
-  protected override parseFacetValue(
-    facetValueIdentifier: FacetValueIdentifier,
-    label: string,
-    count: number
-  ): ProductSearchResultFacetValue {
-    throw new Error('Method not implemented.');
-  }
-  protected override parseFacet(
-    facetIdentifier: FacetIdentifier,
-    facetValue: unknown
-  ): ProductSearchResultFacet {
-    throw new Error('Method not implemented.');
-  }
-  protected override parseVariant(
-    variant: unknown,
-    product: unknown
-  ): ProductSearchResultItemVariant {
-    throw new Error('Method not implemented.');
-  }
 }