@reactionary/source 0.3.18 → 0.6.2

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

@@ -1,32 +1,37 @@
 import type {
-  Inventory,
+  InventoryFactory,
+  InventoryFactoryOutput,
+  InventoryFactoryWithOutput,
   RequestContext,
   Cache,
   InventoryQueryBySKU,
-  InventoryIdentifier,
-  InventoryStatus,
   Result,
   NotFoundError,
 } from '@reactionary/core';
 import { InventoryProvider, InventoryQueryBySKUSchema, InventorySchema, Reactionary, success, error } from '@reactionary/core';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
-import type { InventoryEntry } from '@commercetools/platform-sdk';
 import type { CommercetoolsAPI } from '../core/client.js';
+import type { CommercetoolsInventoryFactory } from '../factories/inventory/inventory.factory.js';
 
-export class CommercetoolsInventoryProvider extends InventoryProvider {
+export class CommercetoolsInventoryProvider<
+  TFactory extends InventoryFactory = CommercetoolsInventoryFactory,
+> extends InventoryProvider<InventoryFactoryOutput<TFactory>> {
   protected config: CommercetoolsConfiguration;
   protected commercetools: CommercetoolsAPI;
+  protected factory: InventoryFactoryWithOutput<TFactory>;
 
   constructor(
     config: CommercetoolsConfiguration,
     cache: Cache,
     context: RequestContext,
-    commercetools: CommercetoolsAPI
+    commercetools: CommercetoolsAPI,
+    factory: InventoryFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
 
     this.config = config;
     this.commercetools = commercetools;
+    this.factory = factory;
   }
 
   protected async getClient() {
@@ -42,7 +47,7 @@ export class CommercetoolsInventoryProvider extends InventoryProvider {
     inputSchema: InventoryQueryBySKUSchema,
     outputSchema: InventorySchema,
   })
-  public override async getBySKU(payload: InventoryQueryBySKU): Promise<Result<Inventory, NotFoundError>> {
+  public override async getBySKU(payload: InventoryQueryBySKU): Promise<Result<InventoryFactoryOutput<TFactory>, NotFoundError>> {
     const client = await this.getClient();
 
     try {
@@ -65,7 +70,7 @@ export class CommercetoolsInventoryProvider extends InventoryProvider {
 
       const result = remote.body.results[0];
 
-      const model = this.parseSingle(result);
+      const model = this.factory.parseInventory(this.context, result);
 
 
       return success(model);
@@ -78,27 +83,4 @@ export class CommercetoolsInventoryProvider extends InventoryProvider {
     }
   }
 
-  protected parseSingle(body: InventoryEntry): Inventory {
-    const identifier = {
-      variant: { sku: body.sku || '' },
-      fulfillmentCenter: {
-        key: body.supplyChannel?.obj?.key || '',
-      },
-    } satisfies InventoryIdentifier;
-
-    const quantity = body.availableQuantity || 0;
-    let status: InventoryStatus = 'outOfStock';
-
-    if (quantity > 0) {
-      status = 'inStock';
-    }
-
-    const result = {
-      identifier,
-      quantity,
-      status,
-    } satisfies Inventory;
-
-    return result;
-  }
 }

package/providers/commercetools/src/providers/order-search.provider.ts

@@ -1,45 +1,46 @@
 import type {
   RequestContext,
   Cache,
+  OrderSearchFactory,
+  OrderSearchFactoryOutput,
+  OrderSearchFactoryWithOutput,
   OrderSearchQueryByTerm,
-  OrderSearchResult,
   Result,
-  OrderSearchIdentifier,
-  MonetaryAmount,
-  Currency,
-  IdentityIdentifier,
-  Address,
-  OrderStatus,
 } from '@reactionary/core';
 import {
   OrderSearchProvider,
   OrderSearchQueryByTermSchema,
   OrderSearchResultSchema,
-  type OrderSearchResultItem,
   Reactionary,
   success,
 } from '@reactionary/core';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
 import type { CommercetoolsAPI } from '../core/client.js';
 import createDebug from 'debug';
-import type { Order as CTOrder, OrderPagedSearchResponse , Address as CTAddress, OrderPagedQueryResponse} from '@commercetools/platform-sdk';
+import type { OrderPagedQueryResponse } from '@commercetools/platform-sdk';
+import type { CommercetoolsOrderSearchFactory } from '../factories/order-search/order-search.factory.js';
 
 const debug = createDebug('reactionary:commercetools:order-search');
 
-export class CommercetoolsOrderSearchProvider extends OrderSearchProvider {
+export class CommercetoolsOrderSearchProvider<
+  TFactory extends OrderSearchFactory = CommercetoolsOrderSearchFactory,
+> extends OrderSearchProvider<OrderSearchFactoryOutput<TFactory>> {
   protected config: CommercetoolsConfiguration;
   protected commercetools: CommercetoolsAPI;
+  protected factory: OrderSearchFactoryWithOutput<TFactory>;
 
   constructor(
     config: CommercetoolsConfiguration,
     cache: Cache,
     context: RequestContext,
-    commercetools: CommercetoolsAPI
+    commercetools: CommercetoolsAPI,
+    factory: OrderSearchFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
 
     this.config = config;
     this.commercetools = commercetools;
+    this.factory = factory;
   }
 
   protected async getClient() {
@@ -54,7 +55,7 @@ export class CommercetoolsOrderSearchProvider extends OrderSearchProvider {
     inputSchema: OrderSearchQueryByTermSchema,
     outputSchema: OrderSearchResultSchema,
   })
-  public async queryByTerm(payload: OrderSearchQueryByTerm): Promise<Result<OrderSearchResult>> {
+  public async queryByTerm(payload: OrderSearchQueryByTerm): Promise<Result<OrderSearchFactoryOutput<TFactory>>> {
     debug('queryByTerm', payload);
 
     const client = await this.getClient();
@@ -116,10 +117,11 @@ export class CommercetoolsOrderSearchProvider extends OrderSearchProvider {
     }).execute();
 
     const responseBody = response.body;
-    const result = this.parsePaginatedResult(
+    const result = this.factory.parseOrderSearchResult(
+      this.context,
       responseBody,
       payload
-    ) as OrderSearchResult;
+    );
 
     if (debug.enabled) {
       debug(
@@ -130,100 +132,4 @@ export class CommercetoolsOrderSearchProvider extends OrderSearchProvider {
     return success(result);
   }
 
-  protected parseAddress(remote: CTAddress) {
-    return {
-      countryCode: remote.country || '',
-      firstName: remote.firstName || '',
-      lastName: remote.lastName || '',
-      streetAddress: remote.streetName || '',
-      streetNumber: remote.streetNumber || '',
-      postalCode: remote.postalCode || '',
-      city: remote.city || '',
-      identifier: {
-        nickName: '',
-      },
-      region: '',
-    } satisfies Address;
-  }
-
-
-  protected parseSingle(body: CTOrder) {
-    const identifier = { key: body.id };
-    const userId: IdentityIdentifier = {
-      userId: body.customerId || body.anonymousId || '',
-    };
-    const customerName = `${body.billingAddress?.firstName} ${body.billingAddress?.lastName}`;
-    const shippingAddress = this.parseAddress(body.shippingAddress!);
-    const orderDate = body.createdAt;
-   let orderStatus: OrderStatus = 'AwaitingPayment';
-    if (body.paymentState === 'Pending' && body.orderState === 'Open') {
-      orderStatus = 'AwaitingPayment';
-    } else if (
-      body.paymentState === 'Paid' &&
-      body.orderState === 'Confirmed'
-    ) {
-      orderStatus = 'ReleasedToFulfillment';
-    }
-    if (body.shipmentState === 'Ready' && body.orderState === 'Confirmed') {
-      orderStatus = 'ReleasedToFulfillment';
-    }
-    if (
-      (body.shipmentState === 'Shipped' ||
-        body.shipmentState === 'Delivered') &&
-      body.orderState === 'Completed'
-    ) {
-      orderStatus = 'Shipped';
-    }
-    let inventoryStatus: OrderSearchResultItem['inventoryStatus'];
-
-    if (orderStatus === 'Shipped') {
-      inventoryStatus = 'Allocated'
-    } else {
-      inventoryStatus = 'NotAllocated'
-    }
-
-    const totalAmount: MonetaryAmount = {
-      currency: body.totalPrice ? body.totalPrice.currencyCode as Currency : this.context.languageContext.currencyCode,
-      value: body.totalPrice ? body.totalPrice.centAmount / 100 : 0
-    };
-
-    const order = {
-      identifier,
-      userId,
-      customerName,
-      shippingAddress,
-      orderDate,
-      orderStatus,
-      inventoryStatus,
-      totalAmount
-    } satisfies OrderSearchResultItem;
-
-    return order;
-  }
-
-  protected parsePaginatedResult(
-    body: OrderPagedQueryResponse,
-    query: OrderSearchQueryByTerm
-  ) {
-    const identifier = {
-      ...query.search,
-    } satisfies OrderSearchIdentifier;
-
-    const orders: OrderSearchResultItem[] = body.results.map((o) => {
-      return this.parseSingle(o);
-    })
-
-    const result = {
-      identifier,
-      pageNumber: (Math.ceil(body.offset / body.limit) || 0) + 1,
-      pageSize: body.limit,
-      totalCount: body.total || 0,
-      totalPages: Math.ceil((body.total || 0) / body.limit || 0) + 1,
-      items: orders,
-    } satisfies OrderSearchResult;
-
-    return result;
-  }
-
-
 }

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

@@ -1,39 +1,37 @@
 import type {
   RequestContext,
   Cache,
-  Order,
+  OrderFactory,
+  OrderFactoryOutput,
+  OrderFactoryWithOutput,
   OrderQueryById,
-  Currency,
-  OrderIdentifier,
-  CostBreakDown,
-  OrderStatus,
-  OrderItem,
-  ProductVariantIdentifier,
-  ItemCostBreakdown,
   Result,
   NotFoundError,
 } from '@reactionary/core';
 import { OrderProvider, OrderQueryByIdSchema, OrderSchema, Reactionary, success, error } from '@reactionary/core';
-import type * as z from 'zod';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
-import type { Order as CTOrder } from '@commercetools/platform-sdk';
-import { type CommercetoolsOrderIdentifier } from '../schema/commercetools.schema.js';
 import type { CommercetoolsAPI } from '../core/client.js';
+import type { CommercetoolsOrderFactory } from '../factories/order/order.factory.js';
 
-export class CommercetoolsOrderProvider extends OrderProvider {
+export class CommercetoolsOrderProvider<
+  TFactory extends OrderFactory = CommercetoolsOrderFactory,
+> extends OrderProvider<OrderFactoryOutput<TFactory>> {
   protected config: CommercetoolsConfiguration;
   protected commercetools: CommercetoolsAPI;
+  protected factory: OrderFactoryWithOutput<TFactory>;
 
   constructor(
     config: CommercetoolsConfiguration,
     cache: Cache,
     context: RequestContext,
-    commercetools: CommercetoolsAPI
+    commercetools: CommercetoolsAPI,
+    factory: OrderFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
 
     this.config = config;
     this.commercetools = commercetools;
+    this.factory = factory;
   }
 
   protected async getClient() {
@@ -48,7 +46,7 @@ export class CommercetoolsOrderProvider extends OrderProvider {
     inputSchema: OrderQueryByIdSchema,
     outputSchema: OrderSchema,
   })
-  public override async getById(payload: OrderQueryById): Promise<Result<Order, NotFoundError>> {
+  public override async getById(payload: OrderQueryById): Promise<Result<OrderFactoryOutput<TFactory>, NotFoundError>> {
     const client = await this.getClient();
 
     try {
@@ -57,7 +55,7 @@ export class CommercetoolsOrderProvider extends OrderProvider {
         .get()
         .execute();
 
-      return success(this.parseSingle(remote.body));
+      return success(this.factory.parseOrder(this.context, remote.body));
     } catch (e) {
       return error<NotFoundError>({
         type: 'NotFound',
@@ -66,133 +64,4 @@ export class CommercetoolsOrderProvider extends OrderProvider {
     }
   }
 
-  protected parseSingle(_body: unknown): Order {
-    const remote = _body as CTOrder;
-
-    const identifier = {
-      key: remote.id,
-      version: remote.version || 0,
-    } satisfies CommercetoolsOrderIdentifier;
-
-    const name = remote.custom?.fields['name'] || '';
-    const description = remote.custom?.fields['description'] || '';
-
-    const grandTotal = remote.totalPrice.centAmount || 0;
-    const shippingTotal = remote.shippingInfo?.price.centAmount || 0;
-    const productTotal = grandTotal - shippingTotal;
-    const taxTotal = remote.taxedPrice?.totalTax?.centAmount || 0;
-    const discountTotal =
-      remote.discountOnTotalPrice?.discountedAmount.centAmount || 0;
-    const surchargeTotal = 0;
-    const currency = remote.totalPrice.currencyCode as Currency;
-
-    const price = {
-      totalTax: {
-        value: taxTotal / 100,
-        currency,
-      },
-      totalDiscount: {
-        value: discountTotal / 100,
-        currency,
-      },
-      totalSurcharge: {
-        value: surchargeTotal / 100,
-        currency,
-      },
-      totalShipping: {
-        value: shippingTotal / 100,
-        currency: remote.shippingInfo?.price.currencyCode as Currency,
-      },
-      totalProductPrice: {
-        value: productTotal / 100,
-        currency,
-      },
-      grandTotal: {
-        value: grandTotal / 100,
-        currency,
-      },
-    } satisfies CostBreakDown;
-
-    let orderStatus: OrderStatus = 'AwaitingPayment';
-    if (remote.paymentState === 'Pending' && remote.orderState === 'Open') {
-      orderStatus = 'AwaitingPayment';
-    } else if (
-      remote.paymentState === 'Paid' &&
-      remote.orderState === 'Confirmed'
-    ) {
-      orderStatus = 'ReleasedToFulfillment';
-    }
-    if (remote.shipmentState === 'Ready' && remote.orderState === 'Confirmed') {
-      orderStatus = 'ReleasedToFulfillment';
-    }
-    if (
-      (remote.shipmentState === 'Shipped' ||
-        remote.shipmentState === 'Delivered') &&
-      remote.orderState === 'Completed'
-    ) {
-      orderStatus = 'Shipped';
-    }
-
-    const items = new Array<OrderItem>();
-    for (const remoteItem of remote.lineItems) {
-      const identifier = {
-        key: remoteItem.id
-      } satisfies OrderIdentifier;
-
-      const variant = {
-        sku: remoteItem.variant.sku || ''
-      } satisfies ProductVariantIdentifier;
-      const quantity = remoteItem.quantity;
-
-      const unitPrice = remoteItem.price.value.centAmount;
-      const totalPrice = remoteItem.totalPrice.centAmount || 0;
-      const totalDiscount = remoteItem.price.discounted?.value.centAmount || 0;
-      const unitDiscount = totalDiscount / remoteItem.quantity;
-
-      const price = {
-        unitPrice: {
-          value: unitPrice / 100,
-          currency,
-        },
-        unitDiscount: {
-          value: unitDiscount / 100,
-          currency,
-        },
-        totalPrice: {
-          value: (totalPrice || 0) / 100,
-          currency,
-        },
-        totalDiscount: {
-          value: totalDiscount / 100,
-          currency,
-        },
-      } satisfies ItemCostBreakdown;
-
-      const item = {
-        identifier,
-        inventoryStatus: 'NotAllocated',
-        price,
-        quantity,
-        variant
-      } satisfies OrderItem;
-
-      items.push(item);
-    }
-
-    const result = {
-      identifier,
-      name,
-      description,
-      price,
-      items,
-      inventoryStatus: 'NotAllocated',
-      paymentInstructions: [],
-      userId: {
-        userId: ''
-      },
-      orderStatus
-    } satisfies Order;
-
-    return result;
-  }
 }

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

@@ -2,42 +2,46 @@ import {
   CustomerPriceQuerySchema,
   ListPriceQuerySchema,
   PriceProvider,
+  type PriceFactory,
+  type PriceFactoryOutput,
+  type PriceFactoryWithOutput,
   PriceSchema,
   Reactionary,
   success,
 } from '@reactionary/core';
 import type {
   RequestContext,
-  Price,
   Cache,
-  Currency,
   CustomerPriceQuery,
   ListPriceQuery,
-  PriceIdentifier,
-  MonetaryAmount,
   Result,
 } from '@reactionary/core';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
 import type {
-  Price as CTPrice,
   ProductVariant as CTProductVariant,
 } from '@commercetools/platform-sdk';
 import type { CommercetoolsAPI } from '../core/client.js';
+import type { CommercetoolsPriceFactory } from '../factories/price/price.factory.js';
 
-export class CommercetoolsPriceProvider extends PriceProvider {
+export class CommercetoolsPriceProvider<
+  TFactory extends PriceFactory = CommercetoolsPriceFactory,
+> extends PriceProvider<PriceFactoryOutput<TFactory>> {
   protected config: CommercetoolsConfiguration;
   protected commercetools: CommercetoolsAPI;
+  protected factory: PriceFactoryWithOutput<TFactory>;
 
   constructor(
     config: CommercetoolsConfiguration,
     cache: Cache,
     context: RequestContext,
-    commercetools: CommercetoolsAPI
+    commercetools: CommercetoolsAPI,
+    factory: PriceFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
 
     this.config = config;
     this.commercetools = commercetools;
+    this.factory = factory;
   }
 
   @Reactionary({
@@ -46,7 +50,7 @@ export class CommercetoolsPriceProvider extends PriceProvider {
   })
   public override async getCustomerPrice(
     payload: CustomerPriceQuery
-  ): Promise<Result<Price>> {
+  ): Promise<Result<PriceFactoryOutput<TFactory>>> {
     const client = await this.getClient();
     let priceChannelId;
     if (this.config.customerPriceChannelKey) {
@@ -76,14 +80,14 @@ export class CommercetoolsPriceProvider extends PriceProvider {
       (x) => x.sku === payload.variant.sku
     );
 
-    return success(this.parseSingle(sku, { includeDiscounts: true }));
+    return success(this.factory.parsePrice(this.context, sku, { includeDiscounts: true }));
   }
 
   @Reactionary({
     inputSchema: ListPriceQuerySchema,
     outputSchema: PriceSchema,
   })
-  public override async getListPrice(payload: ListPriceQuery): Promise<Result<Price>> {
+  public override async getListPrice(payload: ListPriceQuery): Promise<Result<PriceFactoryOutput<TFactory>>> {
     const client = await this.getClient();
     let priceChannelId;
     if (this.config.listPriceChannelKey) {
@@ -112,7 +116,7 @@ export class CommercetoolsPriceProvider extends PriceProvider {
       (x) => x.sku === payload.variant.sku
     );
 
-    return success(this.parseSingle(sku));
+    return success(this.factory.parsePrice(this.context, sku));
   }
 
   protected async getClient() {
@@ -120,48 +124,30 @@ export class CommercetoolsPriceProvider extends PriceProvider {
     return client.withProjectKey({ projectKey: this.config.projectKey });
   }
 
-  protected parseSingle(
-    _body: unknown,
-    options = { includeDiscounts: false }
-  ): Price {
-    const body = _body as CTProductVariant;
-    const price = body.price as CTPrice | undefined;
+  protected async getChannels() {
+    const adminClient = await this.commercetools.getAdminClient();
 
-    if (!price) {
-      return this.createEmptyPriceResult(body.sku!);
-    }
-
-    let unitPrice = {
-      value: price.value.centAmount / 100,
-      currency: price.value.currencyCode as Currency,
-    } satisfies MonetaryAmount;
-
-    let isOnSale = false;
-    if (options.includeDiscounts) {
-      const discountedPrice = price.discounted?.value || price.value;
-      if (price.discounted) {
-        isOnSale = true;
-      }
-      unitPrice = {
-        value: discountedPrice.centAmount / 100,
-        currency: price.value.currencyCode as Currency,
-      } satisfies MonetaryAmount;
-    }
-
-    const identifier = {
-      variant: {
-        sku: body.sku!,
-      },
-    } satisfies PriceIdentifier;
+    const offerPriceChannelPromise = adminClient
+      .withProjectKey({ projectKey: this.config.projectKey })
+      .channels()
+      .withKey({ key: 'Offer Price' })
+      .get()
+      .execute();
+    const listPriceChannelPromise = adminClient
+      .withProjectKey({ projectKey: this.config.projectKey })
+      .channels()
+      .withKey({ key: 'List Price' })
+      .get()
+      .execute();
 
-    const result = {
-      identifier,
-      tieredPrices: [],
-      unitPrice,
-      onSale: isOnSale,
-    } satisfies Price;
+    const [offerChannel, listChannel] = await Promise.all([
+      offerPriceChannelPromise,
+      listPriceChannelPromise,
+    ]);
 
-    return result;
+    return {
+      offer: offerChannel.body.id,
+      list: listChannel.body.id,
+    };
   }
-
 }