@reactionary/source 0.0.52 → 0.2.16

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

@@ -0,0 +1,147 @@
+import {
+  ProfileMutationAddShippingAddressSchema,
+  ProfileMutationMakeShippingAddressDefaultSchema,
+  ProfileMutationRemoveShippingAddressSchema,
+  ProfileMutationSetBillingAddressSchema,
+  ProfileMutationUpdateSchema,
+  ProfileMutationUpdateShippingAddressSchema,
+  ProfileProvider,
+  ProfileQueryByIdSchema,
+  ProfileSchema,
+  Reactionary,
+  type Cache,
+  type IdentityIdentifier,
+  type NotFoundError,
+  type Profile,
+  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';
+
+export class FakeProfileProvider extends ProfileProvider {
+  protected config: FakeConfiguration;
+  private generator: Faker;
+
+  constructor(
+    config: FakeConfiguration,
+    cache: Cache,
+    context: RequestContext
+  ) {
+    super(cache, context);
+    this.generator = new Faker({
+      locale: [en, base],
+      seed: config.seeds.product,
+    });
+    this.config = config;
+  }
+
+  @Reactionary({
+    inputSchema: ProfileQueryByIdSchema,
+    outputSchema: ProfileSchema,
+  })
+  public override async getById(
+    payload: ProfileQuerySelf
+  ): Promise<Result<Profile, NotFoundError>> {
+    const profile = this.composeBaseProfile(payload.identifier);
+
+    return success(profile);
+  }
+
+  @Reactionary({
+    inputSchema: ProfileMutationUpdateSchema,
+    outputSchema: ProfileSchema,
+  })
+  public override async update(
+    payload: ProfileMutationUpdate
+  ): Promise<Result<Profile, NotFoundError>> {
+    const profile = this.composeBaseProfile(payload.identifier);
+
+    return success(profile);
+  }
+
+  @Reactionary({
+    inputSchema: ProfileMutationAddShippingAddressSchema,
+    outputSchema: ProfileSchema,
+  })
+  public override async addShippingAddress(
+    payload: ProfileMutationAddShippingAddress
+  ): Promise<Result<Profile, NotFoundError>> {
+    const profile = this.composeBaseProfile(payload.identifier);
+
+    return success(profile);
+  }
+
+  @Reactionary({
+    inputSchema: ProfileMutationUpdateShippingAddressSchema,
+    outputSchema: ProfileSchema,
+  })
+  public override async updateShippingAddress(
+    payload: ProfileMutationUpdateShippingAddress
+  ): Promise<Result<Profile, NotFoundError>> {
+    const profile = this.composeBaseProfile(payload.identifier);
+
+    return success(profile);
+  }
+
+  @Reactionary({
+    inputSchema: ProfileMutationRemoveShippingAddressSchema,
+    outputSchema: ProfileSchema,
+  })
+  public override async removeShippingAddress(
+    payload: ProfileMutationRemoveShippingAddress
+  ): Promise<Result<Profile, NotFoundError>> {
+    const profile = this.composeBaseProfile(payload.identifier);
+
+    return success(profile);
+  }
+
+  @Reactionary({
+    inputSchema: ProfileMutationMakeShippingAddressDefaultSchema,
+    outputSchema: ProfileSchema,
+  })
+  public override async makeShippingAddressDefault(
+    payload: ProfileMutationMakeShippingAddressDefault
+  ): Promise<Result<Profile, NotFoundError>> {
+    const profile = this.composeBaseProfile(payload.identifier);
+
+    return success(profile);
+  }
+
+  @Reactionary({
+    inputSchema: ProfileMutationSetBillingAddressSchema,
+    outputSchema: ProfileSchema,
+  })
+  public override async setBillingAddress(
+    payload: ProfileMutationSetBillingAddress
+  ): Promise<Result<Profile, NotFoundError>> {
+    const profile = this.composeBaseProfile(payload.identifier);
+
+    return success(profile);
+  }
+
+  protected composeBaseProfile(identifier?: IdentityIdentifier) {
+    const profile = {
+      alternateShippingAddresses: [],
+      createdAt: this.generator.date.past().toISOString(),
+      email: this.generator.internet.email(),
+      emailVerified: true,
+      identifier: identifier || {
+        userId: this.generator.string.uuid(),
+      },
+      phone: this.generator.phone.number(),
+      phoneVerified: true,
+      updatedAt: this.generator.date.past().toISOString(),
+    } satisfies Profile;
+
+    return profile;
+  }
+}

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

@@ -1,46 +1,56 @@
 import type {
   Cache,
+  FulfillmentCenterIdentifier,
   RequestContext,
-  StoreQueryByProximity,
   Store,
+  StoreIdentifier,
+  StoreQueryByProximity,
+  Result
 } from '@reactionary/core';
-import { StoreProvider } from '@reactionary/core';
-import type z from 'zod';
+import { Reactionary, StoreProvider, StoreQueryByProximitySchema, StoreSchema, success } from '@reactionary/core';
+import z from 'zod';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
 import { base, en, Faker } from '@faker-js/faker';
 
-export class FakeStoreProvider<
-  T extends Store = Store
-> extends StoreProvider<T> {
+export class FakeStoreProvider extends StoreProvider {
   protected config: FakeConfiguration;
 
-  constructor(config: FakeConfiguration, schema: z.ZodType<T>, cache: Cache) {
-    super(schema, cache);
+  constructor(config: FakeConfiguration, cache: Cache, context: RequestContext) {
+    super(cache, context);
 
     this.config = config;
   }
 
+  @Reactionary({
+    inputSchema: StoreQueryByProximitySchema,
+    outputSchema: z.array(StoreSchema)
+  })
   public override async queryByProximity(
-    payload: StoreQueryByProximity,
-    reqCtx: RequestContext
-  ): Promise<T[]> {
+    payload: StoreQueryByProximity
+  ): Promise<Result<Store[]>> {
     const generator = new Faker({
       seed: 42,
       locale: [en, base],
     });
 
-    const results = [];
+    const results = new Array<Store>();
 
     for (let i = 0; i < payload.limit; i++) {
-        const model = this.newModel();
-
-        model.name = generator.company.name();
-        model.identifier.key = '' + i;
-        model.fulfillmentCenter.key = '' + i;
-
-        results.push(model);
+        const name = generator.company.name();
+        const identifier = {
+          key: '' + i
+        } satisfies StoreIdentifier;
+        const fulfillmentCenter = {
+          key: '' + i
+        } satisfies FulfillmentCenterIdentifier;
+
+        results.push({
+          fulfillmentCenter,
+          identifier,
+          name
+        });
     }
 
-    return results;
+    return success(results);
   }
 }

package/providers/fake/src/schema/capabilities.schema.ts

@@ -3,13 +3,17 @@ import type { z } from 'zod';
 
 export const FakeCapabilitiesSchema = CapabilitiesSchema.pick({
     product: true,
-    search: true,
+    productSearch: true,
     identity: true,
     category: true,
     cart: true,
     inventory: true,
     store: true,
     price: true,
+    checkout: true,
+    order: true,
+    orderSearch: true,
+    profile: true,    
 }).partial();
 
 export type FakeCapabilities = z.infer<typeof FakeCapabilitiesSchema>;

package/providers/fake/src/test/cart.provider.spec.ts

@@ -4,7 +4,7 @@ import { CartSchema, IdentitySchema, NoOpCache, createInitialRequestContext } fr
 import { getFakerTestConfiguration } from './test-utils.js';
 import { FakeCartProvider } from '../providers/cart.provider.js';
 import { FakeIdentityProvider } from '../providers/index.js';
-
+import { describe, expect, it, beforeAll, beforeEach, assert } from 'vitest';
 
 const testData = {
   skuWithoutTiers: 'SGB-01',
@@ -16,111 +16,90 @@ describe('Fake Cart Provider', () => {
   let identityProvider: FakeIdentityProvider;
   let reqCtx: RequestContext;
 
-  beforeAll( () => {
-    provider = new FakeCartProvider(getFakerTestConfiguration(), CartSchema, new NoOpCache());
-    identityProvider = new FakeIdentityProvider(getFakerTestConfiguration(), IdentitySchema, new NoOpCache());
-  });
-
   beforeEach( () => {
-    reqCtx = createInitialRequestContext()
+    reqCtx = createInitialRequestContext();
+    provider = new FakeCartProvider(getFakerTestConfiguration(), new NoOpCache(), reqCtx);
+    identityProvider = new FakeIdentityProvider(getFakerTestConfiguration(), new NoOpCache(), reqCtx);
   });
 
   describe('anonymous sessions', () => {
-    it('should be able to get an empty cart', async () => {
-      const cart = await provider.getById({
-        cart: { key: '' },
-      }, reqCtx);
-
-      expect(cart.identifier.key).toBeFalsy();
-      expect(cart.items.length).toBe(0);
-      expect(cart.meta?.placeholder).toBe(true);
-
-    });
-
     it('should be able to add an item to a cart', async () => {
       const cart = await provider.add({
-          cart: { key: '' },
-          sku: {
-            key: testData.skuWithoutTiers,
+          variant: {
+            sku: testData.skuWithoutTiers,
           },
           quantity: 1
-      }, reqCtx);
-
-      expect(cart.identifier.key).toBeDefined();
-      expect(cart.items.length).toBe(1);
-      expect(cart.items[0].sku.key).toBe(testData.skuWithoutTiers);
-      expect(cart.items[0].quantity).toBe(1);
-
-      expect(cart.items[0].price.totalPrice.value).toBeGreaterThan(0);
-      expect(cart.items[0].price.totalPrice.currency).toBe(reqCtx.languageContext.currencyCode);
-
-      expect(cart.price.grandTotal.value).toBeGreaterThan(0);
-      expect(cart.price.grandTotal.currency).toBe(reqCtx.languageContext.currencyCode);
-
-      expect(cart.price.grandTotal.value).toBe(cart.items[0].price.totalPrice.value);
-
-
-      expect(cart.meta?.placeholder).toBeFalsy();
-
+      });
+
+      if (!cart.success) {
+        assert.fail();
+      }
+
+      expect(cart.value.identifier.key).toBeDefined();
+      expect(cart.value.items.length).toBe(1);
+      expect(cart.value.items[0].variant.sku).toBe(testData.skuWithoutTiers);
+      expect(cart.value.items[0].quantity).toBe(1);
+      expect(cart.value.items[0].price.totalPrice.value).toBeGreaterThan(0);
+      expect(cart.value.items[0].price.totalPrice.currency).toBe(reqCtx.languageContext.currencyCode);
+      expect(cart.value.price.grandTotal.value).toBeGreaterThan(0);
+      expect(cart.value.price.grandTotal.currency).toBe(reqCtx.languageContext.currencyCode);
+      expect(cart.value.price.grandTotal.value).toBe(cart.value.items[0].price.totalPrice.value);
     });
 
-
     it('should be able to change quantity of an item in a cart', async () => {
-
       const cart = await provider.add({
-          cart: { key: '' },
-          sku: {
-            key: testData.skuWithoutTiers,
+          variant: {
+            sku: testData.skuWithoutTiers,
           },
           quantity: 1
-      }, reqCtx);
+      });
+      
+      if (!cart.success) {
+        assert.fail();
+      }
 
       const updatedCart = await provider.changeQuantity({
-        cart: cart.identifier,
-        item: cart.items[0].identifier,
+        cart: cart.value.identifier,
+        item: cart.value.items[0].identifier,
         quantity: 3
-      }, reqCtx);
-
-      expect(updatedCart.identifier.key).toBe(cart.identifier.key);
-      expect(updatedCart.items.length).toBe(1);
-      expect(updatedCart.items[0].sku.key).toBe(testData.skuWithoutTiers);
-      expect(updatedCart.items[0].quantity).toBe(3);
-      expect(updatedCart.items[0].price.totalPrice.value).toBe(cart.items[0].price.totalPrice.value * 3);
-      expect(updatedCart.items[0].price.unitPrice.value).toBe(cart.items[0].price.unitPrice.value);
-
-
+      });
+
+      if (!updatedCart.success) {
+        assert.fail();
+      }
+
+      expect(updatedCart.value.identifier.key).toBe(cart.value.identifier.key);
+      expect(updatedCart.value.items.length).toBe(1);
+      expect(updatedCart.value.items[0].variant.sku).toBe(testData.skuWithoutTiers);
+      expect(updatedCart.value.items[0].quantity).toBe(3);
+      expect(updatedCart.value.items[0].price.totalPrice.value).toBe(cart.value.items[0].price.totalPrice.value * 3);
+      expect(updatedCart.value.items[0].price.unitPrice.value).toBe(cart.value.items[0].price.unitPrice.value);
     });
 
     it('should be able to remove an item from a cart', async () => {
-
       const cart = await provider.add({
-          cart: { key: '' },
-          sku: {
-            key: testData.skuWithoutTiers,
+          variant: {
+            sku: testData.skuWithoutTiers,
           },
           quantity: 1
-      }, reqCtx);
-
-      const updatedCart = await provider.remove({
-        cart: cart.identifier,
-        item: cart.items[0].identifier,
-      }, reqCtx);
-      expect(updatedCart.identifier.key).toBe(cart.identifier.key);
-      expect(updatedCart.items.length).toBe(0);
-    });
+      });
 
-    /**
-    it('should be able to create a cart for an anonymous user, then login and merge the cart', async () => {
-    });
+      if (!cart.success) {
+        assert.fail();
+      }
 
-    it('should be able to create a cart for an anonymous user, then register and merge the cart', async () => {
+      const updatedCart = await provider.remove({
+        cart: cart.value.identifier,
+        item: cart.value.items[0].identifier,
+      });
+    
+      if (!updatedCart.success) {
+        assert.fail();
+      }
+
+      expect(updatedCart.value.identifier.key).toBe(cart.value.identifier.key);
+      expect(updatedCart.value.items.length).toBe(0);
     });
-
-    it('should be able to clear the cart', async () => { });
-
-    it('should be able to check out the cart', async () => { });
-    */
-
   });
 
 });