@reactionary/source 0.6.1 → 0.6.3

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

@@ -1,36 +1,41 @@
 import {
+  type Cache,
+  type NotFoundError,
+  type ProductFactory,
+  type ProductFactoryOutput,
+  type ProductFactoryWithOutput,
   type ProductQueryById,
-  type ProductQueryBySlug,
-  type RequestContext,
-  type Cache as ReactinaryCache,
-  ProductProvider,
-  Reactionary,
-  type ProductQueryBySKU,
-  type Product,
   ProductQueryByIdSchema,
-  ProductSchema,
-  ProductQueryBySlugSchema,
+  type ProductQueryBySKU,
   ProductQueryBySKUSchema,
+  type ProductQueryBySlug,
+  ProductQueryBySlugSchema,
+  ProductCapability,
+  ProductSchema,
+  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 FakeProductCapability<
+  TFactory extends ProductFactory = FakeProductFactory,
+> extends ProductCapability<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);
   }
 }

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

@@ -0,0 +1,154 @@
+import {
+  AddressSchema,
+  ProfileMutationAddShippingAddressSchema,
+  ProfileMutationMakeShippingAddressDefaultSchema,
+  ProfileMutationRemoveShippingAddressSchema,
+  ProfileMutationSetBillingAddressSchema,
+  ProfileMutationUpdateSchema,
+  ProfileMutationUpdateShippingAddressSchema,
+  ProfileCapability,
+  ProfileQueryByIdSchema,
+  ProfileSchema,
+  Reactionary,
+  type Cache,
+  type Address,
+  type IdentityIdentifier,
+  type NotFoundError,
+  type Profile,
+  type ProfileFactory,
+  type ProfileFactoryOutput,
+  type ProfileFactoryWithOutput,
+  type ProfileMutationAddShippingAddress,
+  type ProfileMutationMakeShippingAddressDefault,
+  type ProfileMutationRemoveShippingAddress,
+  type ProfileMutationSetBillingAddress,
+  type ProfileMutationUpdate,
+  type ProfileMutationUpdateShippingAddress,
+  type ProfileQuerySelf,
+  type RequestContext,
+  type Result,
+  success,
+} from '@reactionary/core';
+import type { FakeConfiguration } from '../schema/configuration.schema.js';
+import { base, en, Faker } from '@faker-js/faker';
+import type { FakeProfileFactory } from '../factories/profile/profile.factory.js';
+
+export class FakeProfileCapability<
+  TFactory extends ProfileFactory = FakeProfileFactory,
+> extends ProfileCapability<ProfileFactoryOutput<TFactory>> {
+  protected config: FakeConfiguration;
+  protected factory: ProfileFactoryWithOutput<TFactory>;
+  private generator: Faker;
+
+  constructor(
+    config: FakeConfiguration,
+    cache: Cache,
+    context: RequestContext,
+    factory: ProfileFactoryWithOutput<TFactory>,
+  ) {
+    super(cache, context);
+    this.generator = new Faker({
+      locale: [en, base],
+      seed: config.seeds.product,
+    });
+    this.config = config;
+    this.factory = factory;
+  }
+
+  @Reactionary({ inputSchema: ProfileQueryByIdSchema, outputSchema: ProfileSchema })
+  public override async getById(
+    payload: ProfileQuerySelf,
+  ): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>> {
+    return success(this.composeProfile(payload.identifier));
+  }
+
+  @Reactionary({ inputSchema: ProfileMutationUpdateSchema, outputSchema: ProfileSchema })
+  public override async update(
+    payload: ProfileMutationUpdate,
+  ): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>> {
+    return success(this.composeProfile(payload.identifier));
+  }
+
+  @Reactionary({
+    inputSchema: ProfileMutationAddShippingAddressSchema,
+    outputSchema: ProfileSchema,
+  })
+  public override async addShippingAddress(
+    payload: ProfileMutationAddShippingAddress,
+  ): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>> {
+    return success(this.composeProfile(payload.identifier));
+  }
+
+  @Reactionary({
+    inputSchema: ProfileMutationUpdateShippingAddressSchema,
+    outputSchema: ProfileSchema,
+  })
+  public override async updateShippingAddress(
+    payload: ProfileMutationUpdateShippingAddress,
+  ): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>> {
+    return success(this.composeProfile(payload.identifier));
+  }
+
+  @Reactionary({
+    inputSchema: ProfileMutationRemoveShippingAddressSchema,
+    outputSchema: ProfileSchema,
+  })
+  public override async removeShippingAddress(
+    payload: ProfileMutationRemoveShippingAddress,
+  ): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>> {
+    return success(this.composeProfile(payload.identifier));
+  }
+
+  @Reactionary({
+    inputSchema: ProfileMutationMakeShippingAddressDefaultSchema,
+    outputSchema: ProfileSchema,
+  })
+  public override async makeShippingAddressDefault(
+    payload: ProfileMutationMakeShippingAddressDefault,
+  ): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>> {
+    return success(this.composeProfile(payload.identifier));
+  }
+
+  @Reactionary({
+    inputSchema: ProfileMutationSetBillingAddressSchema,
+    outputSchema: ProfileSchema,
+  })
+  public override async setBillingAddress(
+    payload: ProfileMutationSetBillingAddress,
+  ): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>> {
+    return success(this.composeProfile(payload.identifier));
+  }
+
+  protected composeProfile(identifier: IdentityIdentifier): ProfileFactoryOutput<TFactory> {
+    const baseProfile = {
+      identifier,
+      email: this.generator.internet.email(),
+      phone: this.generator.phone.number(),
+      emailVerified: true,
+      phoneVerified: true,
+      createdAt: this.generator.date.past().toISOString(),
+      updatedAt: this.generator.date.recent().toISOString(),
+      billingAddress: this.createEmptyAddress(),
+      shippingAddress: this.createEmptyAddress(),
+      alternateShippingAddresses: [],
+    } satisfies Profile;
+
+    return this.factory.parseProfile(this.context, baseProfile);
+  }
+
+  protected createEmptyAddress(): Address {
+    return AddressSchema.parse({
+      identifier: {
+        nickName: this.generator.person.firstName().toLowerCase(),
+      },
+      firstName: this.generator.person.firstName(),
+      lastName: this.generator.person.lastName(),
+      streetAddress: this.generator.location.street(),
+      streetNumber: this.generator.location.buildingNumber(),
+      city: this.generator.location.city(),
+      region: this.generator.location.state(),
+      postalCode: this.generator.location.zipCode(),
+      countryCode: this.generator.location.countryCode('alpha-2'),
+    });
+  }
+}

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

@@ -0,0 +1,72 @@
+import type {
+  Cache,
+  FulfillmentCenterIdentifier,
+  RequestContext,
+  Result,
+  StoreFactory,
+  StoreFactoryOutput,
+  StoreFactoryWithOutput,
+  StoreIdentifier,
+  StoreQueryByProximity,
+} from '@reactionary/core';
+import {
+  Reactionary,
+  StoreCapability,
+  StoreQueryByProximitySchema,
+  StoreSchema,
+  success,
+} from '@reactionary/core';
+import * as z from 'zod';
+import type { FakeConfiguration } from '../schema/configuration.schema.js';
+import { base, en, Faker } from '@faker-js/faker';
+import type { FakeStoreFactory } from '../factories/store/store.factory.js';
+
+export class FakeStoreCapability<
+  TFactory extends StoreFactory = FakeStoreFactory,
+> extends StoreCapability<StoreFactoryOutput<TFactory>> {
+  protected config: FakeConfiguration;
+  protected factory: StoreFactoryWithOutput<TFactory>;
+
+  constructor(
+    config: FakeConfiguration,
+    cache: Cache,
+    context: RequestContext,
+    factory: StoreFactoryWithOutput<TFactory>,
+  ) {
+    super(cache, context);
+
+    this.config = config;
+    this.factory = factory;
+  }
+
+  @Reactionary({
+    inputSchema: StoreQueryByProximitySchema,
+    outputSchema: z.array(StoreSchema),
+  })
+  public override async queryByProximity(
+    payload: StoreQueryByProximity,
+  ): Promise<Result<StoreFactoryOutput<TFactory>[]>> {
+    const generator = new Faker({
+      seed: 42,
+      locale: [en, base],
+    });
+
+    const results: StoreFactoryOutput<TFactory>[] = [];
+
+    for (let i = 0; i < payload.limit; i++) {
+      results.push(
+        this.factory.parseStore(this.context, {
+          identifier: {
+            key: `${i}`,
+          } satisfies StoreIdentifier,
+          fulfillmentCenter: {
+            key: `${i}`,
+          } satisfies FulfillmentCenterIdentifier,
+          name: generator.company.name(),
+        }),
+      );
+    }
+
+    return success(results);
+  }
+}

package/packages/fake/src/core/initialize.ts

@@ -0,0 +1,274 @@
+import type { Cache as ReactinaryCache, RequestContext } from '@reactionary/core';
+import {
+  CartIdentifierSchema as CoreCartIdentifierSchema,
+  CartSchema as CoreCartSchema,
+  CategoryPaginatedResultSchema as CoreCategoryPaginatedResultSchema,
+  CategorySchema as CoreCategorySchema,
+  CheckoutSchema as CoreCheckoutSchema,
+  IdentitySchema as CoreIdentitySchema,
+  InventorySchema as CoreInventorySchema,
+  OrderSchema as CoreOrderSchema,
+  OrderSearchResultSchema as CoreOrderSearchResultSchema,
+  PaymentMethodSchema as CorePaymentMethodSchema,
+  PriceSchema as CorePriceSchema,
+  ProductAssociationSchema as CoreProductAssociationSchema,
+  ProductRatingSummarySchema as CoreProductRatingSummarySchema,
+  ProductReviewPaginatedResultSchema as CoreProductReviewPaginatedResultSchema,
+  ProductReviewSchema as CoreProductReviewSchema,
+  ProductSchema as CoreProductSchema,
+  ProductSearchResultSchema as CoreProductSearchResultSchema,
+  ProfileSchema as CoreProfileSchema,
+  ShippingMethodSchema as CoreShippingMethodSchema,
+  StoreSchema as CoreStoreSchema,
+} from '@reactionary/core';
+import { FakeProductCapability } from '../capabilities/product.capability.js';
+import { FakeProductSearchCapability } from '../capabilities/product-search.capability.js';
+import type { FakeConfiguration } from '../schema/configuration.schema.js';
+import type { FakeCapabilities } from '../schema/capabilities.schema.js';
+import { FakeCapabilitiesSchema } from '../schema/capabilities.schema.js';
+import { FakeCategoryCapability } from '../capabilities/category.capability.js';
+import {
+  FakeCartCapability,
+  FakeIdentityCapability,
+  FakeInventoryCapability,
+  FakePriceCapability,
+  FakeStoreCapability,
+} from '../capabilities/index.js';
+import { FakeCheckoutCapability } from '../capabilities/checkout.capability.js';
+import { FakeOrderSearchCapability } from '../capabilities/order-search.capability.js';
+import { FakeOrderCapability } from '../capabilities/order.capability.js';
+import { FakeProfileCapability } from '../capabilities/profile.capability.js';
+import { FakeProductReviewsCapability } from '../capabilities/product-reviews.capability.js';
+import { FakeProductAssociationsCapability } from '../capabilities/product-associations.capability.js';
+import {
+  FakeCartFactory,
+  FakeCategoryFactory,
+  FakeCheckoutFactory,
+  FakeIdentityFactory,
+  FakeInventoryFactory,
+  FakeOrderFactory,
+  FakeOrderSearchFactory,
+  FakePriceFactory,
+  FakeProductAssociationsFactory,
+  FakeProductFactory,
+  FakeProductReviewsFactory,
+  FakeProductSearchFactory,
+  FakeProfileFactory,
+  FakeStoreFactory,
+} from '../factories/index.js';
+import {
+  type FakeClientFromCapabilities,
+  resolveCapabilityWithFactory,
+} from './initialize.types.js';
+
+export function withFakeCapabilities<T extends FakeCapabilities>(
+  configuration: FakeConfiguration,
+  capabilities: T,
+) {
+  return (
+    cache: ReactinaryCache,
+    context: RequestContext,
+  ): FakeClientFromCapabilities<T> => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const client: any = {};
+    const caps = FakeCapabilitiesSchema.parse(capabilities);
+
+    const buildCapabilityArgs = <TFactory,>(factory: TFactory) => ({
+      cache,
+      context,
+      config: configuration,
+      factory,
+    });
+
+    if (caps.product?.enabled) {
+      client.product = resolveCapabilityWithFactory(
+        capabilities.product,
+        {
+          factory: new FakeProductFactory(CoreProductSchema),
+          capability: (args) =>
+            new FakeProductCapability(args.config, args.cache, args.context, args.factory),
+        },
+        buildCapabilityArgs,
+      );
+    }
+
+    if (caps.productSearch?.enabled) {
+      client.productSearch = resolveCapabilityWithFactory(
+        capabilities.productSearch,
+        {
+          factory: new FakeProductSearchFactory(CoreProductSearchResultSchema),
+          capability: (args) =>
+            new FakeProductSearchCapability(args.config, args.cache, args.context, args.factory),
+        },
+        buildCapabilityArgs,
+      );
+    }
+
+    if (caps.category?.enabled) {
+      client.category = resolveCapabilityWithFactory(
+        capabilities.category,
+        {
+          factory: new FakeCategoryFactory(
+            CoreCategorySchema,
+            CoreCategoryPaginatedResultSchema,
+          ),
+          capability: (args) =>
+            new FakeCategoryCapability(args.config, args.cache, args.context, args.factory),
+        },
+        buildCapabilityArgs,
+      );
+    }
+
+    if (caps.cart?.enabled) {
+      client.cart = resolveCapabilityWithFactory(
+        capabilities.cart,
+        {
+          factory: new FakeCartFactory(CoreCartSchema, CoreCartIdentifierSchema),
+          capability: (args) =>
+            new FakeCartCapability(args.config, args.cache, args.context, args.factory),
+        },
+        buildCapabilityArgs,
+      );
+    }
+
+    if (caps.inventory?.enabled) {
+      client.inventory = resolveCapabilityWithFactory(
+        capabilities.inventory,
+        {
+          factory: new FakeInventoryFactory(CoreInventorySchema),
+          capability: (args) =>
+            new FakeInventoryCapability(args.config, args.cache, args.context, args.factory),
+        },
+        buildCapabilityArgs,
+      );
+    }
+
+    if (caps.store?.enabled) {
+      client.store = resolveCapabilityWithFactory(
+        capabilities.store,
+        {
+          factory: new FakeStoreFactory(CoreStoreSchema),
+          capability: (args) =>
+            new FakeStoreCapability(args.config, args.cache, args.context, args.factory),
+        },
+        buildCapabilityArgs,
+      );
+    }
+
+    if (caps.price?.enabled) {
+      client.price = resolveCapabilityWithFactory(
+        capabilities.price,
+        {
+          factory: new FakePriceFactory(CorePriceSchema),
+          capability: (args) =>
+            new FakePriceCapability(args.config, args.cache, args.context, args.factory),
+        },
+        buildCapabilityArgs,
+      );
+    }
+
+    if (caps.identity?.enabled) {
+      client.identity = resolveCapabilityWithFactory(
+        capabilities.identity,
+        {
+          factory: new FakeIdentityFactory(CoreIdentitySchema),
+          capability: (args) =>
+            new FakeIdentityCapability(args.config, args.cache, args.context, args.factory),
+        },
+        buildCapabilityArgs,
+      );
+    }
+
+    if (caps.checkout?.enabled) {
+      client.checkout = resolveCapabilityWithFactory(
+        capabilities.checkout,
+        {
+          factory: new FakeCheckoutFactory(
+            CoreCheckoutSchema,
+            CoreShippingMethodSchema,
+            CorePaymentMethodSchema,
+          ),
+          capability: (args) =>
+            new FakeCheckoutCapability(args.config, args.cache, args.context, args.factory),
+        },
+        buildCapabilityArgs,
+      );
+    }
+
+    if (caps.orderSearch?.enabled) {
+      client.orderSearch = resolveCapabilityWithFactory(
+        capabilities.orderSearch,
+        {
+          factory: new FakeOrderSearchFactory(CoreOrderSearchResultSchema),
+          capability: (args) =>
+            new FakeOrderSearchCapability(args.config, args.cache, args.context, args.factory),
+        },
+        buildCapabilityArgs,
+      );
+    }
+
+    if (caps.order?.enabled) {
+      client.order = resolveCapabilityWithFactory(
+        capabilities.order,
+        {
+          factory: new FakeOrderFactory(CoreOrderSchema),
+          capability: (args) =>
+            new FakeOrderCapability(args.config, args.cache, args.context, args.factory),
+        },
+        buildCapabilityArgs,
+      );
+    }
+
+    if (caps.profile?.enabled) {
+      client.profile = resolveCapabilityWithFactory(
+        capabilities.profile,
+        {
+          factory: new FakeProfileFactory(CoreProfileSchema),
+          capability: (args) =>
+            new FakeProfileCapability(args.config, args.cache, args.context, args.factory),
+        },
+        buildCapabilityArgs,
+      );
+    }
+
+    if (caps.productReviews?.enabled) {
+      client.productReviews = resolveCapabilityWithFactory(
+        capabilities.productReviews,
+        {
+          factory: new FakeProductReviewsFactory(
+            CoreProductRatingSummarySchema,
+            CoreProductReviewSchema,
+            CoreProductReviewPaginatedResultSchema,
+          ),
+          capability: (args) =>
+            new FakeProductReviewsCapability(
+              args.config,
+              args.cache,
+              args.context,
+              args.factory,
+            ),
+        },
+        buildCapabilityArgs,
+      );
+    }
+
+    if (caps.productAssociations?.enabled) {
+      client.productAssociations = resolveCapabilityWithFactory(
+        capabilities.productAssociations,
+        {
+          factory: new FakeProductAssociationsFactory(CoreProductAssociationSchema),
+          capability: (args) =>
+            new FakeProductAssociationsCapability(
+              args.config,
+              args.cache,
+              args.context,
+              args.factory,
+            ),
+        },
+        buildCapabilityArgs,
+      );
+    }
+
+    return client;
+  };
+}