@reactionary/source 0.3.18 → 0.6.2

package/providers/fake/src/providers/product-reviews.provider.ts

@@ -1,54 +1,61 @@
 import {
+  ProductRatingSummarySchema,
+  ProductReviewPaginatedResultSchema,
+  ProductReviewSchema,
   ProductReviewsProvider,
   Reactionary,
-  success,
   error,
-  ProductReviewSchema,
-  ProductRatingSummarySchema,
-  ProductReviewPaginatedResultSchema,
-} from '@reactionary/core';
-import type {
-  ProductReview,
-  ProductRatingSummary,
-  ProductReviewPaginatedResult,
-  ProductReviewsListQuery,
-  ProductReviewsGetRatingSummaryQuery,
-  ProductReviewMutationSubmit,
-  Result,
-  RequestContext,
-  Cache,
-  NotFoundError,
-  InvalidInputError,
-  ProductIdentifier,
+  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 FakeProductReviewsProvider<
+  TFactory extends ProductReviewsFactory = FakeProductReviewsFactory,
+> extends ProductReviewsProvider<
+  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

@@ -6,40 +6,42 @@ import {
   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 FakeSearchProvider<
+  TFactory extends ProductSearchFactory = FakeProductSearchFactory,
+> extends ProductSearchProvider<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.');
-  }
 }

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

@@ -1,36 +1,41 @@
 import {
+  type Cache,
+  type NotFoundError,
+  type ProductFactory,
+  type ProductFactoryOutput,
+  type ProductFactoryWithOutput,
   type ProductQueryById,
+  ProductQueryByIdSchema,
+  type ProductQueryBySKU,
+  ProductQueryBySKUSchema,
   type ProductQueryBySlug,
-  type RequestContext,
-  type Cache as ReactinaryCache,
+  ProductQueryBySlugSchema,
   ProductProvider,
-  Reactionary,
-  type ProductQueryBySKU,
-  type Product,
-  ProductQueryByIdSchema,
   ProductSchema,
-  ProductQueryBySlugSchema,
-  ProductQueryBySKUSchema,
+  type RequestContext,
   type Result,
-  error,
+  Reactionary,
   success,
-  type NotFoundError,
 } from '@reactionary/core';
-import type * as z from 'zod';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
 import { base, en, Faker } from '@faker-js/faker';
+import type { FakeProductFactory } from '../factories/product/product.factory.js';
 
-export class FakeProductProvider extends ProductProvider {
+export class FakeProductProvider<
+  TFactory extends ProductFactory = FakeProductFactory,
+> extends ProductProvider<ProductFactoryOutput<TFactory>> {
   protected config: FakeConfiguration;
+  protected factory: ProductFactoryWithOutput<TFactory>;
 
   constructor(
     config: FakeConfiguration,
-    cache: ReactinaryCache,
-    context: RequestContext
+    cache: Cache,
+    context: RequestContext,
+    factory: ProductFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
-
     this.config = config;
+    this.factory = factory;
   }
 
   @Reactionary({
@@ -42,9 +47,9 @@ export class FakeProductProvider extends ProductProvider {
     localeDependentCaching: true,
   })
   public override async getById(
-    payload: ProductQueryById
-  ): Promise<Result<Product>> {
-    return success(this.parseSingle(payload.identifier.key));
+    payload: ProductQueryById,
+  ): Promise<Result<ProductFactoryOutput<TFactory>>> {
+    return success(this.composeSingle(payload.identifier.key));
   }
 
   @Reactionary({
@@ -52,9 +57,9 @@ export class FakeProductProvider extends ProductProvider {
     outputSchema: ProductSchema,
   })
   public override async getBySlug(
-    payload: ProductQueryBySlug
-  ): Promise<Result<Product, NotFoundError>> {
-    return success(this.parseSingle(payload.slug));
+    payload: ProductQueryBySlug,
+  ): Promise<Result<ProductFactoryOutput<TFactory>, NotFoundError>> {
+    return success(this.composeSingle(payload.slug));
   }
 
   @Reactionary({
@@ -62,26 +67,23 @@ export class FakeProductProvider extends ProductProvider {
     outputSchema: ProductSchema,
   })
   public override async getBySKU(
-    payload: ProductQueryBySKU
-  ): Promise<Result<Product>> {
-    return success(this.parseSingle(payload.variant.sku));
+    payload: ProductQueryBySKU,
+  ): Promise<Result<ProductFactoryOutput<TFactory>>> {
+    return success(this.composeSingle(payload.variant.sku));
   }
 
-  protected parseSingle(body: string): Product {
+  protected composeSingle(body: string): ProductFactoryOutput<TFactory> {
     const generator = new Faker({
       seed: 42,
       locale: [en, base],
     });
 
-    const key = body;
-
-    // Merge the generated data into the model
     const result = {
       identifier: {
-        key: key,
+        key: body,
       },
       name: generator.commerce.productName(),
-      slug: key,
+      slug: body,
       brand: '',
       longDescription: '',
       mainVariant: {
@@ -103,8 +105,8 @@ export class FakeProductProvider extends ProductProvider {
       published: true,
       sharedAttributes: [],
       variants: [],
-    } satisfies Product;
+    };
 
-    return result;
+    return this.factory.parseProduct(this.context, result);
   }
 }