@reactionary/source 0.0.52 → 0.2.16

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

@@ -3,68 +3,79 @@ import type {
   Cache,
   Order,
   OrderQueryById,
-  Currency} from '@reactionary/core';
-import { OrderItemSchema, OrderProvider } from '@reactionary/core';
+  Currency,
+  OrderIdentifier,
+  CostBreakDown,
+  OrderStatus,
+  OrderItem,
+  ProductVariantIdentifier,
+  ItemCostBreakdown,
+  Result,
+  NotFoundError,
+} from '@reactionary/core';
+import { OrderProvider, OrderQueryByIdSchema, OrderSchema, Reactionary, success, error } from '@reactionary/core';
 import type z from 'zod';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
-import { CommercetoolsClient } from '../core/client.js';
 import type { Order as CTOrder } from '@commercetools/platform-sdk';
-import { CommercetoolsOrderIdentifierSchema } from '../schema/commercetools.schema.js';
-export class CommercetoolsOrderProvider<
-  T extends Order = Order
-> extends OrderProvider<T> {
+import { type CommercetoolsOrderIdentifier } from '../schema/commercetools.schema.js';
+import type { CommercetoolsAPI } from '../core/client.js';
+
+export class CommercetoolsOrderProvider extends OrderProvider {
   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 }).me().orders();
+  protected async getClient() {
+    const client = await this.commercetools.getClient();
+    return client
+      .withProjectKey({ projectKey: this.config.projectKey })
+      .me()
+      .orders();
   }
 
-
-  public override async getById(payload: OrderQueryById, reqCtx: RequestContext): Promise<T> {
-    const client = await new CommercetoolsClient(this.config).getClient(reqCtx);
+  @Reactionary({
+    inputSchema: OrderQueryByIdSchema,
+    outputSchema: OrderSchema,
+  })
+  public override async getById(payload: OrderQueryById): Promise<Result<Order, NotFoundError>> {
+    const client = await this.getClient();
 
     try {
       const remote = await client
-        .withProjectKey({ projectKey: this.config.projectKey })
-        .orders()
         .withId({ ID: payload.order.key })
         .get()
         .execute();
 
-      return this.parseSingle(remote.body, reqCtx);
+      return success(this.parseSingle(remote.body));
     } catch (e) {
-      return this.createEmptyOrder();
+      return error<NotFoundError>({
+        type: 'NotFound',
+        identifier: payload
+      })
     }
   }
 
+  protected parseSingle(_body: unknown): Order {
+    const remote = _body as CTOrder;
 
-  protected override parseSingle(_body: unknown, reqCtx: RequestContext): T {
-      const remote = _body as CTOrder;
-      const result = this.newModel();
-
-      result.identifier = CommercetoolsOrderIdentifierSchema.parse({
-        key: remote.id,
-        version: remote.version || 0,
-      });
-
+    const identifier = {
+      key: remote.id,
+      version: remote.version || 0,
+    } satisfies CommercetoolsOrderIdentifier;
 
-
-    result.name = remote.custom?.fields['name'] || '';
-    result.description = remote.custom?.fields['description'] || '';
+    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;
@@ -75,7 +86,7 @@ export class CommercetoolsOrderProvider<
     const surchargeTotal = 0;
     const currency = remote.totalPrice.currencyCode as Currency;
 
-    result.price = {
+    const price = {
       totalTax: {
         value: taxTotal / 100,
         currency,
@@ -100,33 +111,45 @@ export class CommercetoolsOrderProvider<
         value: grandTotal / 100,
         currency,
       },
-    };
-
-    if (remote.paymentState  === 'Pending' && remote.orderState === 'Open') {
-      result.orderStatus = 'AwaitingPayment';
-    } else if (remote.paymentState  === 'Paid' && remote.orderState === 'Confirmed') {
-      result.orderStatus = 'ReleasedToFulfillment';
+    } 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') {
-      result.orderStatus = 'ReleasedToFulfillment';
+      orderStatus = 'ReleasedToFulfillment';
     }
-    if ( (remote.shipmentState === 'Shipped' || remote.shipmentState === 'Delivered') && remote.orderState === 'Completed') {
-      result.orderStatus = 'Shipped';
+    if (
+      (remote.shipmentState === 'Shipped' ||
+        remote.shipmentState === 'Delivered') &&
+      remote.orderState === 'Completed'
+    ) {
+      orderStatus = 'Shipped';
     }
 
+    const items = new Array<OrderItem>();
     for (const remoteItem of remote.lineItems) {
-      const item = OrderItemSchema.parse({});
+      const identifier = {
+        key: remoteItem.id
+      } satisfies OrderIdentifier;
 
-      item.identifier.key = remoteItem.id;
-      item.sku.key = remoteItem.variant.sku || '';
-      item.quantity = remoteItem.quantity;
+      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;
 
-      item.price = {
+      const price = {
         unitPrice: {
           value: unitPrice / 100,
           currency,
@@ -143,21 +166,33 @@ export class CommercetoolsOrderProvider<
           value: totalDiscount / 100,
           currency,
         },
-      };
+      } satisfies ItemCostBreakdown;
+
+      const item = {
+        identifier,
+        inventoryStatus: 'NotAllocated',
+        price,
+        quantity,
+        variant
+      } satisfies OrderItem;
 
-      result.items.push(item);
+      items.push(item);
     }
 
-    result.meta = {
-      cache: {
-        hit: false,
-        key: this.generateCacheKeySingle(result.identifier, reqCtx),
+    const result = {
+      identifier,
+      name,
+      description,
+      price,
+      items,
+      inventoryStatus: 'NotAllocated',
+      paymentInstructions: [],
+      userId: {
+        userId: ''
       },
-      placeholder: false,
-    };
-
-
+      orderStatus
+    } satisfies Order;
 
-      return this.assert(result);
+    return result;
   }
 }

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

@@ -1,150 +1,180 @@
-import { PriceProvider, TieredPriceSchema } from '@reactionary/core';
-import type { PriceQueryBySku, RequestContext , Price, Cache, Currency, TieredPrice } from '@reactionary/core';
-import type z from 'zod';
+import {
+  CustomerPriceQuerySchema,
+  ListPriceQuerySchema,
+  PriceProvider,
+  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 { CommercetoolsClient } from '../core/client.js';
-import type { Price as CTPrice, ProductVariant as CTProductVariant } from '@commercetools/platform-sdk';
-export class CommercetoolsPriceProvider<
-  T extends Price = Price
-> extends PriceProvider<T> {
-  protected config: CommercetoolsConfiguration;
-
+import type {
+  Price as CTPrice,
+  ProductVariant as CTProductVariant,
+} from '@commercetools/platform-sdk';
+import type { CommercetoolsAPI } from '../core/client.js';
 
+export class CommercetoolsPriceProvider extends PriceProvider {
+  protected config: CommercetoolsConfiguration;
+  protected commercetools: CommercetoolsAPI;
 
-  constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, cache: Cache) {
-    super(schema, cache);
+  constructor(
+    config: CommercetoolsConfiguration,
+    cache: Cache,
+    context: RequestContext,
+    commercetools: CommercetoolsAPI
+  ) {
+    super(cache, context);
 
     this.config = config;
+    this.commercetools = commercetools;
   }
 
-
-  protected async getClient(reqCtx: RequestContext) {
-    const client = await new CommercetoolsClient(this.config).getClient(
-      reqCtx
+  @Reactionary({
+    inputSchema: CustomerPriceQuerySchema,
+    outputSchema: PriceSchema,
+  })
+  public override async getCustomerPrice(
+    payload: CustomerPriceQuery
+  ): Promise<Result<Price>> {
+    const client = await this.getClient();
+    const priceChannelId = 'ee6e75e9-c9ab-4e2f-85f1-d8c734d0cb86';
+
+    const response = await client
+      .productProjections()
+      .get({
+        queryArgs: {
+          staged: false,
+          priceCountry: this.context.taxJurisdiction.countryCode,
+          priceCustomerGroup: undefined,
+          priceChannel: priceChannelId,
+          priceCurrency: this.context.languageContext.currencyCode,
+          where: 'variants(sku in (:skus)) OR (masterVariant(sku in (:skus))) ',
+          'var.skus': [payload.variant.sku],
+          limit: 1,
+        },
+      })
+      .execute();
+
+    const result = response.body.results[0];
+    const sku = [result.masterVariant, ...result.variants].find(
+      (x) => x.sku === payload.variant.sku
     );
-    return client.withProjectKey({ projectKey: this.config.projectKey }).productProjections()
-  }
-
-
-
-  public override async getBySKUs(payload: PriceQueryBySku[], reqCtx: RequestContext): Promise<T[]> {
-
-    const client = await this.getClient(reqCtx);
 
-    //  AND (validFrom is not defined OR validFrom <= now()) AND (validUntil is not defined OR validUntil >= now())
-
-    const channels = await this.getChannels(reqCtx);
-
-    const response = await client.get({
-      queryArgs: {
-        staged: false,
-        priceCountry: reqCtx.taxJurisdiction.countryCode,
-        priceCustomerGroup: undefined,
-        priceChannel: channels.offerChannelGUID,
-        priceCurrency: reqCtx.languageContext.currencyCode,
-       // storeProjection: reqCtx.storeIdentifier?.key || undefined,
-        where: 'variants(sku in (:skus)) OR (masterVariant(sku in (:skus))) ',
-        'var.skus': payload.map(p => p.sku.key),
-        limit: payload.length,
-      },
-    }).execute();
-
-    const result = [];
-    const allReturnedVariants = [...response.body.results.map(x => x.variants).flat(), ...response.body.results.map(x => x.masterVariant).flat()];
-    // Now we need to match the skus requested with the prices returned.
-    for(const p of payload) {
-      const foundSku = allReturnedVariants.find(v => v.sku === p.sku.key);
-
-      if (!foundSku) {
-        result.push(this.createEmptyPriceResult(p.sku.key, reqCtx.languageContext.currencyCode ));
-      } else {
-        result.push(this.parseSingle(foundSku, reqCtx));
-      }
-    }
-
-    return result;
+    return success(this.parseSingle(sku, { includeDiscounts: true }));
   }
 
+  @Reactionary({
+    inputSchema: ListPriceQuerySchema,
+    outputSchema: PriceSchema,
+  })
+  public override async getListPrice(payload: ListPriceQuery): Promise<Result<Price>> {
+    const client = await this.getClient();
+    const priceChannelId = 'ee6e75e9-c9ab-4e2f-85f1-d8c734d0cb86';
+
+    const response = await client
+      .productProjections()
+      .get({
+        queryArgs: {
+          staged: false,
+          priceCountry: this.context.taxJurisdiction.countryCode,
+          priceCustomerGroup: undefined,
+          priceChannel: priceChannelId,
+          priceCurrency: this.context.languageContext.currencyCode,
+          where: 'variants(sku in (:skus)) OR (masterVariant(sku in (:skus))) ',
+          'var.skus': [payload.variant.sku],
+          limit: 1,
+        },
+      })
+      .execute();
+
+    const result = response.body.results[0];
+    const sku = [result.masterVariant, ...result.variants].find(
+      (x) => x.sku === payload.variant.sku
+    );
 
-  public override async getBySKU(
-    payload: PriceQueryBySku,
-    reqCtx: RequestContext
-  ): Promise<T> {
-    return this.getBySKUs([payload], reqCtx).then(r => r[0]);
+    return success(this.parseSingle(sku));
   }
 
+  protected async getClient() {
+    const client = await this.commercetools.getClient();
+    return client.withProjectKey({ projectKey: this.config.projectKey });
+  }
 
-
-  protected override parseSingle(_body: unknown, reqCtx: RequestContext): T {
+  protected parseSingle(
+    _body: unknown,
+    options = { includeDiscounts: false }
+  ): Price {
     const body = _body as CTProductVariant;
     const price = body.price as CTPrice | undefined;
 
     if (!price) {
-      return this.createEmptyPriceResult(body.sku!, reqCtx.languageContext.currencyCode);
+      return this.createEmptyPriceResult(body.sku!);
     }
 
-    const base = this.newModel();
-    base.unitPrice = {
-      value: (price.value.centAmount / 100),
+    let unitPrice = {
+      value: price.value.centAmount / 100,
       currency: price.value.currencyCode as Currency,
-    };
+    } satisfies MonetaryAmount;
 
-    if (price.tiers && price.tiers.length > 0) {
-      const p  = price.tiers.map(x => {
-        const tp: TieredPrice = TieredPriceSchema.parse({});
-        tp.minimumQuantity = x.minimumQuantity;
-        tp.price = {
-          value: (x.value.centAmount / 100),
-          currency: x.value.currencyCode as Currency,
-        };
-        return tp;
-      });
-      base.tieredPrices = p;
-    }
+    if (options.includeDiscounts) {
+      const discountedPrice = price.discounted?.value || price.value;
 
-    base.identifier = {
-      sku: {
-        key: body.sku!
-      }
-    };
+      unitPrice = {
+        value: discountedPrice.centAmount / 100,
+        currency: price.value.currencyCode as Currency,
+      } satisfies MonetaryAmount;
+    }
 
-    base.meta = {
-      cache: { hit: false, key: this.generateCacheKeySingle(base.identifier, reqCtx) },
-      placeholder: false
-    };
+    const identifier = {
+      variant: {
+        sku: body.sku!,
+      },
+    } satisfies PriceIdentifier;
 
-    return this.assert(base);
+    const result = {
+      identifier,
+      tieredPrices: [],
+      unitPrice,
+    } satisfies Price;
 
+    return result;
   }
 
-  protected async getChannels(reqCtx: RequestContext) {
-
-    if (!(reqCtx.session['commercetools'] && reqCtx.session['commercetools'].offerChannelGUID && reqCtx.session['commercetools'].listChannelGUID)) {
-
-      /**
-       * Bah - have to be an admin to call these....
-       * So either we cache them in the session, or we make the user provide them in the config.
-       */
-
-   /*
-        const configClient = await new CommercetoolsClient(this.config).getClient(reqCtx);
-        const offerPriceChannelPromise = configClient.withProjectKey({ projectKey: this.config.projectKey }).channels().withKey({ key: 'Offer Price'}).get().execute();
-        const listPriceChannelPromise = configClient.withProjectKey({ projectKey: this.config.projectKey }).channels().withKey({ key: 'List Price'}).get().execute();
-
-        const [offerChannel, listChannel] = await Promise.all([offerPriceChannelPromise, listPriceChannelPromise]);
-    */
-
-        reqCtx.session['commercetools'] = {
-          ...reqCtx.session['commercetools'],
-          offerChannelGUID: undefined,
-          listChannelGUID: undefined
-        };
-    }
-
+  protected async getChannels() {
+    const adminClient = await this.commercetools.getAdminClient();
+
+    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 [offerChannel, listChannel] = await Promise.all([
+      offerPriceChannelPromise,
+      listPriceChannelPromise,
+    ]);
 
     return {
-      offerChannelGUID: reqCtx.session['commercetools'].offerChannelGUID,
-      listChannelGUID: reqCtx.session['commercetools'].listChannelGUID
-    }
+      offer: offerChannel.body.id,
+      list: listChannel.body.id,
+    };
   }
 }