@reactionary/source 0.0.52 → 0.2.16

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

@@ -1,61 +1,478 @@
 import type {
   Profile,
+  ProfileMutationAddShippingAddress,
+  ProfileMutationMakeShippingAddressDefault,
+  ProfileMutationRemoveShippingAddress,
+  ProfileMutationSetBillingAddress,
   ProfileMutationUpdate,
   ProfileQuerySelf,
   RequestContext,
+  Result,
+  NotFoundError,
+  InvalidInputError,
+  Address,
+  ProfileMutationUpdateShippingAddress
+} from '@reactionary/core';
+import {
+  ProfileMutationUpdateSchema,
+  ProfileProvider,
+  ProfileSchema,
+  Reactionary,
+  success,
+  error,
+  ProfileMutationSetBillingAddressSchema,
+  ProfileMutationRemoveShippingAddressSchema,
+  ProfileMutationAddShippingAddressSchema
 } from '@reactionary/core';
-import { ProfileProvider } from '@reactionary/core';
 import type z from 'zod';
-import { CommercetoolsClient } from '../core/client.js';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
 import type { Cache } from '@reactionary/core';
-import type { Customer } from '@commercetools/platform-sdk';
+import type { Customer, MyCustomerUpdateAction, Address as CTAddress } from '@commercetools/platform-sdk';
+import type { CommercetoolsAPI } from '../core/client.js';
 
-export class CommercetoolsProfileProvider<
-  T extends Profile = Profile
-> extends ProfileProvider<T> {
+export class CommercetoolsProfileProvider extends ProfileProvider {
   protected config: CommercetoolsConfiguration;
+  protected commercetools: CommercetoolsAPI;
 
   constructor(
     config: CommercetoolsConfiguration,
-    schema: z.ZodType<T>,
-    cache: Cache
+    cache: Cache,
+    context: RequestContext,
+    commercetools: CommercetoolsAPI
   ) {
-    super(schema, cache);
+    super(cache, context);
 
     this.config = config;
+    this.commercetools = commercetools;
   }
 
-  protected async getClient(reqCtx: RequestContext) {
-    const client = await new CommercetoolsClient(this.config).getClient(reqCtx);
+  protected async getClient() {
+    const client = await this.commercetools.getClient();
     return client.withProjectKey({ projectKey: this.config.projectKey });
   }
 
-  public override async getSelf(
-    payload: ProfileQuerySelf,
-    reqCtx: RequestContext
-  ): Promise<T> {
-    const client = await this.getClient(reqCtx);
+  public override async getById(payload: ProfileQuerySelf): Promise<Result<Profile, NotFoundError>> {
+    const client = await this.getClient();
+
+    const remote = await client.me().get().execute();
+
+    if (remote.body.id !== payload.identifier.userId) {
+      return error<NotFoundError>({
+        type: 'NotFound',
+        identifier: payload.identifier,
+      });
+    }
+
+    const model = this.parseSingle(remote.body);
+    return success(model);
+  }
+
+
+
+  @Reactionary({
+    inputSchema: ProfileMutationAddShippingAddressSchema,
+    outputSchema: ProfileSchema,
+  })
+  public override async addShippingAddress(payload: ProfileMutationAddShippingAddress): Promise<Result<Profile, NotFoundError>> {
+    const client = await this.getClient();
+
+    const remote = await client.me().get().execute();
+    let customer = remote.body;
+
+    if (customer.id !== payload.identifier.userId) {
+      return error<NotFoundError>({
+        type: 'NotFound',
+        identifier: payload.identifier,
+      });
+    }
+
+    const updateResponse = await client
+      .me()
+      .post({
+        body: {
+          version: customer.version,
+          actions: [
+            {
+              action: 'addAddress',
+              address: this.createCTAddressDraft(payload.address)
+            }
+          ] as MyCustomerUpdateAction[],
+        }
+      })
+      .execute();
+    customer = updateResponse.body;
+    const model = this.parseSingle(customer);
+    return success(model);
+  }
+
+  public override async updateShippingAddress(payload: ProfileMutationUpdateShippingAddress): Promise<Result<Profile, NotFoundError>> {
+    const client = await this.getClient();
+
+    const remote = await client.me().get().execute();
+    let customer = remote.body;
+
+    if (customer.id !== payload.identifier.userId) {
+      return error<NotFoundError>({
+        type: 'NotFound',
+        identifier: payload.identifier,
+      });
+    }
+
+    const targetAddress = customer.addresses.find(addr => addr.key === payload.address.identifier.nickName);
+
+    if (!targetAddress) {
+      return error<NotFoundError>({
+        type: 'NotFound',
+        identifier: payload.identifier,
+      });
+    }
+
+
+    const updateResponse = await client
+      .me()
+      .post({
+        body: {
+          version: customer.version,
+          actions: [
+            {
+              action: 'changeAddress',
+              addressId: targetAddress.id!,
+              address: this.createCTAddressDraft(payload.address)
+            }
+          ] as MyCustomerUpdateAction[],
+        }
+      })
+      .execute();
+    customer = updateResponse.body;
+    const model = this.parseSingle(customer);
+    return success(model);
+  }
+
+  @Reactionary({
+    inputSchema: ProfileMutationRemoveShippingAddressSchema,
+    outputSchema: ProfileSchema,
+  })
+  public override async removeShippingAddress(payload: ProfileMutationRemoveShippingAddress): Promise<Result<Profile, NotFoundError>> {
+    const client = await this.getClient();
+
+    const remote = await client.me().get().execute();
+    let customer = remote.body;
+
+    if (customer.id !== payload.identifier.userId) {
+      return error<NotFoundError>({
+        type: 'NotFound',
+        identifier: payload.identifier,
+      });
+    }
+
+    const updateActions: MyCustomerUpdateAction[] = [];
+    const addressToRemove = customer.addresses.find(addr => addr.key === payload.addressIdentifier.nickName);
+
+    if (addressToRemove) {
+      updateActions.push({
+        action: 'removeAddress',
+        addressId: addressToRemove.id!
+      });
+    } else {
+      return error<NotFoundError>({
+        type: 'NotFound',
+        identifier: payload.identifier,
+      });
+    }
+
+    /**
+     * if the address we remove is the default shipping address, we check to see if there are other non-billing addresses available, and make a random one
+     * the new shipping  address
+     */
+    const needsNewDefaultShippingAddress = addressToRemove && customer.defaultShippingAddressId === addressToRemove.id;
+    if (needsNewDefaultShippingAddress) {
+      const newDefaultAddress = customer.addresses.find(addr => addr.id !== addressToRemove.id && addr.id !== customer.defaultBillingAddressId);
+      if (newDefaultAddress) {
+        updateActions.push({
+          action: 'setDefaultShippingAddress',
+          addressKey: newDefaultAddress.key
+        });
+      }
+    }
+
+
+    const updateResponse = await client
+      .me()
+      .post({
+        body: {
+          version: customer.version,
+          actions: updateActions,
+        },
+      })
+      .execute();
+    customer = updateResponse.body;
+
+    const model = this.parseSingle(customer);
+    return success(model);
+  }
+
+
+
+  public override async makeShippingAddressDefault(payload: ProfileMutationMakeShippingAddressDefault): Promise<Result<Profile, NotFoundError>> {
+    const client = await this.getClient();
 
     const remote = await client.me().get().execute();
-    const model = this.parseSingle(remote.body, reqCtx);
+    let customer = remote.body;
+
+    if (customer.id !== payload.identifier.userId) {
+      return error<NotFoundError>({
+        type: 'NotFound',
+        identifier: payload.identifier,
+      });
+    }
+    const addressToMakeDefault = customer.addresses.find(addr => addr.key === payload.addressIdentifier.nickName);
+
+    if (!addressToMakeDefault) {
+      return error<NotFoundError>({
+        type: 'NotFound',
+        identifier: payload.identifier,
+      });
+    }
+
+    if (addressToMakeDefault.id === customer.defaultBillingAddressId) {
+      return error<InvalidInputError>({
+        type: 'InvalidInput',
+        error: {
+          field: 'addressIdentifier',
+          message: 'Cannot set shipping address as default billing address',
+        }
+      });
+    }
 
-    return model;
+
+    const updateResponse = await client
+      .me()
+      .post({
+        body: {
+          version: customer.version,
+          actions: [
+            {
+              action: 'setDefaultShippingAddress',
+              addressKey: addressToMakeDefault.key
+            }
+          ] as MyCustomerUpdateAction[],
+        },
+      })
+      .execute();
+    customer = updateResponse.body;
+    const model = this.parseSingle(customer);
+    return success(model);
   }
 
-  public override async update(
-    payload: ProfileMutationUpdate,
-    reqCtx: RequestContext
-  ): Promise<T> {
-    throw new Error('Method not implemented.');
+
+  @Reactionary({
+    inputSchema: ProfileMutationSetBillingAddressSchema,
+    outputSchema: ProfileSchema,
+  })
+  public override async setBillingAddress(payload: ProfileMutationSetBillingAddress): Promise<Result<Profile, NotFoundError>> {
+    const client = await this.getClient();
+
+    const remote = await client.me().get().execute();
+    let customer = remote.body;
+
+    if (customer.id !== payload.identifier.userId) {
+      return error<NotFoundError>({
+        type: 'NotFound',
+        identifier: payload.identifier,
+      });
+    }
+
+    const updateActions: MyCustomerUpdateAction[] = [];
+    const mainAddress = customer.defaultBillingAddressId ?  customer.addresses.find(addr => addr.id === customer.defaultBillingAddressId): null;
+    if (!mainAddress) {
+      const newAddress = this.createCTAddressDraft(payload.address);
+      updateActions.push({
+        action: 'addAddress',
+        address: newAddress
+      });
+      updateActions.push({
+        action: 'setDefaultBillingAddress',
+        addressKey: newAddress.key
+      });
+    } else {
+      updateActions.push({
+        action: 'changeAddress',
+        addressId: mainAddress.id!,
+        address: this.createCTAddressDraft( payload.address)
+      });
+    }
+
+    if (updateActions.length > 0) {
+      const updateResponse = await client
+        .me()
+        .post({
+          body: {
+            version: customer.version,
+            actions: updateActions,
+          },
+        })
+        .execute();
+      customer = updateResponse.body;
+    }
+    const model = this.parseSingle(customer);
+    return success(model);
   }
 
-  protected override parseSingle(body: Customer, reqCtx: RequestContext): T {
-    const model = this.newModel();
+  @Reactionary({
+    inputSchema: ProfileMutationUpdateSchema,
+    outputSchema: ProfileSchema,
+  })
+  public override async update(payload: ProfileMutationUpdate): Promise<Result<Profile, NotFoundError>> {
+    const client = await this.getClient();
+
+    const remote = await client.me().get().execute();
+    let customer = remote.body;
+
+    if (customer.id !== payload.identifier.userId) {
+      return error<NotFoundError>({
+        type: 'NotFound',
+        identifier: payload.identifier,
+      });
+    }
+
+    const updateActions: MyCustomerUpdateAction[] = [];
+    if (payload.email !== undefined) {
+      updateActions.push({
+        action: 'changeEmail',
+        email: payload.email,
+      });
+    }
+
+
+    const mainAddress = customer.defaultBillingAddressId ?  customer.addresses.find(addr => addr.id === customer.defaultBillingAddressId): null;
+    if (!mainAddress) {
+      updateActions.push({
+        action: 'addAddress',
+        address: {
+          key: `billing-address-${customer.id}`,
+          email: payload.email || customer.email,
+          phone: payload.phone,
+          country: this.context.taxJurisdiction.countryCode
+        }
+      });
+
+      updateActions.push({
+        action: 'setDefaultBillingAddress',
+        addressKey: `billing-address-${customer.id}`
+      });
+    } else {
+      updateActions.push({
+        action: 'changeAddress',
+        addressId: mainAddress.id!,
+        address: {
+          ...mainAddress,
+          email: payload.email || customer.email,
+          phone: payload.phone
+        }
+      });
+    }
+
+    if (updateActions.length > 0) {
+      const updateResponse = await client
+        .me()
+        .post({
+          body: {
+            version: customer.version,
+            actions: updateActions,
+          },
+        })
+        .execute();
+      customer = updateResponse.body;
+    }
+    const model = this.parseSingle(customer);
+    return success(model);
+
+  }
+
+  protected parseAddress(address: CTAddress): Address {
+    const result = {
+      identifier: {
+        nickName: address.key || '',
+      },
+      firstName: address.firstName || '',
+      lastName: address.lastName || '',
+      streetAddress: address.streetName || '',
+      streetNumber: address.streetNumber || '',
+      city: address.city || '',
+      region: address.region || '',
+      postalCode: address.postalCode || '',
+      countryCode: address.country,
+    } satisfies Address;
+
+    return result;
+  }
+
+  protected parseSingle(body: Customer): Profile {
+    const email = body.email;
+    const emailVerified = body.isEmailVerified;
+    let defaultCTBillingAddress = body.addresses.find(addr => addr.id === body.defaultBillingAddressId);
+    const phone = defaultCTBillingAddress?.phone ?? '';
+
+
+    // if we only have the phone number on the billing address, we dont really have a billing address, so we ignore it
+    if (this.isIncompleteAddress(defaultCTBillingAddress)) {
+      defaultCTBillingAddress = undefined;
+    }
+
+    const defaultCTShippingAddress = body.addresses.find(addr => addr.id === body.defaultShippingAddressId);
+
+    const alternateShippingAddresses = body.addresses.filter(x => x.id !== body.defaultBillingAddressId && x.id !== body.defaultShippingAddressId).map(addr => this.parseAddress(addr));
+    const billingAddress = defaultCTBillingAddress ? this.parseAddress(defaultCTBillingAddress) : undefined;
+    const shippingAddress = defaultCTShippingAddress ? this.parseAddress(defaultCTShippingAddress) : undefined;
+
+    const result = {
+      identifier: {
+        userId: body.id
+      },
+      email,
+      emailVerified,
+      alternateShippingAddresses,
+      billingAddress: billingAddress,
+      shippingAddress: shippingAddress,
+      createdAt: body.createdAt,
+      phone,
+      phoneVerified: false,
+      updatedAt: body.lastModifiedAt
+    } satisfies Profile;
+
+    return result;
+  }
+
+  protected createCTAddressDraft( address: Address): CTAddress {
+    return {
+      key: address.identifier.nickName,
+      firstName: address.firstName,
+      lastName: address.lastName,
+      streetName: address.streetAddress,
+      streetNumber: address.streetNumber,
+      postalCode: address.postalCode,
+      city: address.city,
+      region: address.region,
+      country: address.countryCode || this.context.taxJurisdiction.countryCode,
+    };
+  }
 
-    model.email = body.email;
-    model.emailVerified = body.isEmailVerified;
 
-    return model;
+   /**
+   * Checks if an address only contains phone information and lacks essential address fields.
+   * An address is considered incomplete if it exists but has no firstName, lastName, streetName,
+   * streetNumber, or city.
+   * @param address - The address to check, or undefined
+   * @returns true if the address exists but lacks essential fields, false otherwise (including when address is undefined)
+   */
+  protected isIncompleteAddress(address: CTAddress | undefined): boolean {
+    if (!address) {
+      return false;
+    }
+    return !address.firstName &&
+           !address.lastName &&
+           !address.streetName &&
+           !address.streetNumber &&
+           !address.city;
   }
 }

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

@@ -2,77 +2,91 @@ import type {
   RequestContext,
   Cache,
   StoreQueryByProximity,
+  Store,
+  StoreIdentifier,
+  FulfillmentCenterIdentifier,
+  Result,
 } from '@reactionary/core';
-import { StoreProvider } from '@reactionary/core';
-import type z from 'zod';
+import { Reactionary, StoreProvider, StoreQueryByProximitySchema, StoreSchema, success, error } from '@reactionary/core';
+import z from 'zod';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
-import { CommercetoolsClient } from '../core/client.js';
 import type { Channel } from '@commercetools/platform-sdk';
-import type { Store } from '@reactionary/core';
+import type { CommercetoolsAPI } from '../core/client.js';
 
-export class CommercetoolsStoreProvider<
-  T extends Store = Store
-> extends StoreProvider<T> {
+export class CommercetoolsStoreProvider extends StoreProvider {
   protected config: CommercetoolsConfiguration;
+  protected commercetools: CommercetoolsAPI;
 
   constructor(
     config: CommercetoolsConfiguration,
-    schema: z.ZodType<T>,
-    cache: Cache
+    cache: Cache,
+    context: RequestContext,
+    commercetools: CommercetoolsAPI
   ) {
-    super(schema, cache);
+    super(cache, context);
 
     this.config = config;
+    this.commercetools = commercetools;
   }
 
-  protected async getClient(reqCtx: RequestContext) {
-    const client = await new CommercetoolsClient(this.config).getClient(reqCtx);
-    return client
-      .withProjectKey({ projectKey: this.config.projectKey });
+  protected async getClient() {
+    const client = await this.commercetools.getClient();
+    return client.withProjectKey({ projectKey: this.config.projectKey });
   }
 
+  @Reactionary({
+    inputSchema: StoreQueryByProximitySchema,
+    outputSchema: z.array(StoreSchema),
+  })
   public override async queryByProximity(
-    payload: StoreQueryByProximity,
-    reqCtx: RequestContext
-  ): Promise<Array<T>> {
-    const client = await this.getClient(reqCtx);
+    payload: StoreQueryByProximity
+  ): Promise<Result<Array<Store>>> {
+    const client = await this.getClient();
 
     const remote = await client
-        .channels()
-        .get({
-            queryArgs: {
-                limit: payload.limit,
-                where: `geoLocation within circle(${ payload.longitude }, ${ payload.latitude }, ${payload.distance * 1000}) AND roles contains any ("InventorySupply")`
-            }
-        }).execute();
+      .channels()
+      .get({
+        queryArgs: {
+          limit: payload.limit,
+          where: `geoLocation within circle(${payload.longitude}, ${
+            payload.latitude
+          }, ${
+            payload.distance * 1000
+          }) AND roles contains any ("InventorySupply")`,
+        },
+      })
+      .execute();
 
     const results = [];
 
     for (const r of remote.body.results) {
-        results.push(this.parseSingle(r, reqCtx));
+      results.push(this.parseSingle(r));
     }
 
-    return results;
+    return success(results);
   }
 
-  protected override parseSingle(
-    body: Channel,
-    reqCtx: RequestContext
-  ): T {
-    const model = this.newModel();
+  protected parseSingle(body: Channel): Store {
 
+    let name = '';
     if (body.name && body.name['la']) {
-        model.name = body.name['la'];
+      name = body.name['la'];
     }
 
-    model.identifier = {
-        key: body.key
-    };
+    const identifier = {
+      key: body.key,
+    } satisfies StoreIdentifier;
 
-    model.fulfillmentCenter = {
-        key: body.key
-    };
+    const fulfillmentCenter = {
+      key: body.key,
+    } satisfies FulfillmentCenterIdentifier;
 
-    return model;
+    const result = {
+      identifier,
+      fulfillmentCenter,
+      name,
+    } satisfies Store;
+
+    return result;
   }
 }

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

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

package/providers/commercetools/src/schema/commercetools.schema.ts

@@ -1,5 +1,5 @@
-import { CartIdentifierSchema, CheckoutIdentifierSchema, OrderIdentifierSchema } from "@reactionary/core";
-import z from "zod";
+import { BaseModelSchema, CartIdentifierSchema, CategoryIdentifierSchema, CheckoutIdentifierSchema, OrderIdentifierSchema } from "@reactionary/core";
+import { keyof, z } from "zod";
 
 export const CommercetoolsCartIdentifierSchema = CartIdentifierSchema.extend({
     version: z.number().default(0)
@@ -14,7 +14,21 @@ export const CommercetoolsCheckoutIdentifierSchema = CheckoutIdentifierSchema.ex
     version: z.number().default(0)
 });
 
-export type CommercetoolsCheckoutIdentifier = z.infer<typeof CommercetoolsCheckoutIdentifierSchema>;
+export const CommercetoolsResolveCategoryQueryByKeySchema = z.object({
+    key: z.string().describe('The key of the category to resolve.'),
+});
+export const CommercetoolsResolveCategoryQueryByIdSchema = z.object({
+    id: z.string().describe('The ID of the category to resolve.'),
+});
+export const CommercetoolsCategoryLookupSchema = BaseModelSchema.extend({
+    id: z.string(),
+    key: z.string().optional(),
+    name: z.record(z.string(), z.string()),
+});
 
+export type CommercetoolsCheckoutIdentifier = z.infer<typeof CommercetoolsCheckoutIdentifierSchema>;
 export type CommercetoolsCartIdentifier = z.infer<typeof CommercetoolsCartIdentifierSchema>;
 export type CommercetoolsOrderIdentifier = z.infer<typeof CommercetoolsOrderIdentifierSchema>;
+export type CommercetoolsResolveCategoryQueryByKey = z.infer<typeof CommercetoolsResolveCategoryQueryByKeySchema>;
+export type CommercetoolsResolveCategoryQueryById = z.infer<typeof CommercetoolsResolveCategoryQueryByIdSchema>;
+export type CommercetoolsCategoryLookup = z.infer<typeof CommercetoolsCategoryLookupSchema>;

package/providers/commercetools/src/schema/configuration.schema.ts

@@ -9,6 +9,7 @@ export const CommercetoolsConfigurationSchema = z.looseObject({
     clientSecret: z.string(),
     scopes: z.array(z.string()).default(() => []),
     paymentMethods: PaymentMethodSchema.array().optional().default(() => []),
+    facetFieldsForSearch: z.array(z.string()).default(() => []),
 });
 
 export type CommercetoolsConfiguration = z.infer<typeof CommercetoolsConfigurationSchema>;