@reactionary/source 0.6.1 → 0.6.3

package/{providers/commercetools/src/providers/inventory.provider.ts → packages/commercetools/src/capabilities/inventory.capability.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 { InventoryCapability, 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 CommercetoolsInventoryCapability<
+  TFactory extends InventoryFactory = CommercetoolsInventoryFactory,
+> extends InventoryCapability<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/packages/commercetools/src/capabilities/order-search.capability.ts

@@ -0,0 +1,135 @@
+import type {
+  RequestContext,
+  Cache,
+  OrderSearchFactory,
+  OrderSearchFactoryOutput,
+  OrderSearchFactoryWithOutput,
+  OrderSearchQueryByTerm,
+  Result,
+} from '@reactionary/core';
+import {
+  OrderSearchCapability,
+  OrderSearchQueryByTermSchema,
+  OrderSearchResultSchema,
+  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 { 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 CommercetoolsOrderSearchCapability<
+  TFactory extends OrderSearchFactory = CommercetoolsOrderSearchFactory,
+> extends OrderSearchCapability<OrderSearchFactoryOutput<TFactory>> {
+  protected config: CommercetoolsConfiguration;
+  protected commercetools: CommercetoolsAPI;
+  protected factory: OrderSearchFactoryWithOutput<TFactory>;
+
+  constructor(
+    config: CommercetoolsConfiguration,
+    cache: Cache,
+    context: RequestContext,
+    commercetools: CommercetoolsAPI,
+    factory: OrderSearchFactoryWithOutput<TFactory>,
+  ) {
+    super(cache, context);
+
+    this.config = config;
+    this.commercetools = commercetools;
+    this.factory = factory;
+  }
+
+  protected async getClient() {
+    const client = await this.commercetools.getClient();
+    return client
+      .withProjectKey({ projectKey: this.config.projectKey })
+      .me()
+      .orders();
+  }
+
+  @Reactionary({
+    inputSchema: OrderSearchQueryByTermSchema,
+    outputSchema: OrderSearchResultSchema,
+  })
+  public async queryByTerm(payload: OrderSearchQueryByTerm): Promise<Result<OrderSearchFactoryOutput<TFactory>>> {
+    debug('queryByTerm', payload);
+
+    const client = await this.getClient();
+    const where: string[] = [];
+    if (payload.search) {
+      if (payload.search.term) {
+        debug('Search by term is not implemented yet in CommercetoolsOrderSearchCapability');
+      }
+
+      if (payload.search.partNumber) {
+        for (const partNumber of payload.search.partNumber) {
+          where.push(`lineItems(variant(sku="${partNumber}"))`);
+        }
+      }
+
+      if (payload.search.user && payload.search.user.userId) {
+
+//        where.push(`customerId="${payload.search.user.userId}"`);
+      }
+
+      if (payload.search.orderStatus) {
+        const orderStatusWhere = payload.search.orderStatus.map(x => {
+          let mappedStatus = 'Open';
+          if (x === 'AwaitingPayment') {
+            mappedStatus = `Open`
+          }
+          if (x === 'ReleasedToFulfillment') {
+            mappedStatus = `Confirmed`
+          }
+          if (x === 'Shipped') {
+            mappedStatus = `Complete`
+          }
+          if (x === 'Cancelled') {
+            mappedStatus = `Cancelled`
+          }
+          return `orderState="${mappedStatus}"`
+        }).join(' OR ');
+        where.push(orderStatusWhere);
+      }
+
+      if (payload.search.startDate) {
+        where.push(`createdAt >= "${payload.search.startDate}"`);
+      }
+
+      if (payload.search.endDate) {
+        where.push(`createdAt <= "${payload.search.endDate}"`);
+      }
+    }
+
+    const response = await client.get({
+      queryArgs: {
+        where: where,
+        withTotal: true,
+          limit: payload.search.paginationOptions.pageSize,
+          offset:
+            (payload.search.paginationOptions.pageNumber - 1) *
+            payload.search.paginationOptions.pageSize,
+      }
+    }).execute();
+
+    const responseBody = response.body;
+    const result = this.factory.parseOrderSearchResult(
+      this.context,
+      responseBody,
+      payload
+    );
+
+    if (debug.enabled) {
+      debug(
+        `Search for term "${payload.search.term}" returned ${responseBody.results.length} orders (page ${payload.search.paginationOptions.pageNumber} of ${result.totalPages})`
+      );
+    }
+
+    return success(result);
+  }
+
+}

package/packages/commercetools/src/capabilities/order.capability.ts

@@ -0,0 +1,67 @@
+import type {
+  RequestContext,
+  Cache,
+  OrderFactory,
+  OrderFactoryOutput,
+  OrderFactoryWithOutput,
+  OrderQueryById,
+  Result,
+  NotFoundError,
+} from '@reactionary/core';
+import { OrderCapability, OrderQueryByIdSchema, OrderSchema, Reactionary, success, error } from '@reactionary/core';
+import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
+import type { CommercetoolsAPI } from '../core/client.js';
+import type { CommercetoolsOrderFactory } from '../factories/order/order.factory.js';
+
+export class CommercetoolsOrderCapability<
+  TFactory extends OrderFactory = CommercetoolsOrderFactory,
+> extends OrderCapability<OrderFactoryOutput<TFactory>> {
+  protected config: CommercetoolsConfiguration;
+  protected commercetools: CommercetoolsAPI;
+  protected factory: OrderFactoryWithOutput<TFactory>;
+
+  constructor(
+    config: CommercetoolsConfiguration,
+    cache: Cache,
+    context: RequestContext,
+    commercetools: CommercetoolsAPI,
+    factory: OrderFactoryWithOutput<TFactory>,
+  ) {
+    super(cache, context);
+
+    this.config = config;
+    this.commercetools = commercetools;
+    this.factory = factory;
+  }
+
+  protected async getClient() {
+    const client = await this.commercetools.getClient();
+    return client
+      .withProjectKey({ projectKey: this.config.projectKey })
+      .me()
+      .orders();
+  }
+
+  @Reactionary({
+    inputSchema: OrderQueryByIdSchema,
+    outputSchema: OrderSchema,
+  })
+  public override async getById(payload: OrderQueryById): Promise<Result<OrderFactoryOutput<TFactory>, NotFoundError>> {
+    const client = await this.getClient();
+
+    try {
+      const remote = await client
+        .withId({ ID: payload.order.key })
+        .get()
+        .execute();
+
+      return success(this.factory.parseOrder(this.context, remote.body));
+    } catch (e) {
+      return error<NotFoundError>({
+        type: 'NotFound',
+        identifier: payload
+      })
+    }
+  }
+
+}

package/{providers/commercetools/src/providers/price.provider.ts → packages/commercetools/src/capabilities/price.capability.ts}

@@ -1,43 +1,47 @@
 import {
   CustomerPriceQuerySchema,
   ListPriceQuerySchema,
-  PriceProvider,
+  PriceCapability,
+  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 CommercetoolsPriceCapability<
+  TFactory extends PriceFactory = CommercetoolsPriceFactory,
+> extends PriceCapability<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,
+    };
   }
-
 }

package/{providers/commercetools/src/providers/product-associations.provider.ts → packages/commercetools/src/capabilities/product-associations.capability.ts}

@@ -1,47 +1,45 @@
 import {
-  ProductAssociationsProvider,
+  type ProductAssociationsFactory,
+  type ProductAssociationsFactoryOutput,
+  type ProductAssociationsFactoryWithOutput,
+  ProductAssociationsCapability,
   Reactionary,
-  ImageSchema,
-  ProductVariantOptionSchema,
-  ProductOptionIdentifierSchema,
-  ProductSearchResultItemVariantSchema,
-  ProductVariantIdentifierSchema,
   success,
   error,
 } from '@reactionary/core';
 import type {
-  ProductVariantIdentifier,
   ProductIdentifier,
-  ProductAssociation,
-  ProductSearchResultItem,
-  ProductSearchResultItemVariant,
   ProductAssociationsGetAccessoriesQuery,
   ProductAssociationsGetSparepartsQuery,
   ProductAssociationsGetReplacementsQuery,
   Result,
   RequestContext,
   Cache,
-  ProductOptionIdentifier,
-  ProductVariantOption,
   NotFoundError,
 } from '@reactionary/core';
-import type { ProductProjection, ProductVariant as CTProductVariant } from '@commercetools/platform-sdk';
+import type { ProductProjection } from '@commercetools/platform-sdk';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
 import type { CommercetoolsAPI } from '../core/client.js';
+import type { CommercetoolsProductAssociationsFactory } from '../factories/product-associations/product-associations.factory.js';
 
-export class CommercetoolsProductAssociationsProvider extends ProductAssociationsProvider {
+export class CommercetoolsProductAssociationsCapability<
+  TFactory extends ProductAssociationsFactory = CommercetoolsProductAssociationsFactory,
+> extends ProductAssociationsCapability<ProductAssociationsFactoryOutput<TFactory>> {
   protected config: CommercetoolsConfiguration;
   protected commercetools: CommercetoolsAPI;
+  protected factory: ProductAssociationsFactoryWithOutput<TFactory>;
 
   constructor(
     config: CommercetoolsConfiguration,
     cache: Cache,
     context: RequestContext,
-    commercetools: CommercetoolsAPI
+    commercetools: CommercetoolsAPI,
+    factory: ProductAssociationsFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
     this.config = config;
     this.commercetools = commercetools;
+    this.factory = factory;
   }
 
   protected async getClient() {
@@ -49,7 +47,7 @@ export class CommercetoolsProductAssociationsProvider extends ProductAssociation
     return client.withProjectKey({ projectKey: this.config.projectKey });
   }
 
-  protected async fetchAssociatedProductsFor(productKey: ProductIdentifier, maxNumberOfAssociations: number, attributeName: string): Promise<ProductSearchResultItem[]> {
+  protected async fetchAssociatedProductsFor(productKey: ProductIdentifier, maxNumberOfAssociations: number, attributeName: string): Promise<ProductProjection[]> {
       const client = await this.getClient();
 
       const product = await client
@@ -74,7 +72,7 @@ export class CommercetoolsProductAssociationsProvider extends ProductAssociation
         if (!associationsAttr) {
           return [];
         }
-        const associatedProductSearchItems: ProductSearchResultItem[] = [];
+        const associatedProductSearchItems: ProductProjection[] = [];
 
         // look up each associated product,
         const allAssociatedProductPromises = (associationsAttr.value as string[]).map(async (associatedProductId) => {
@@ -90,34 +88,12 @@ export class CommercetoolsProductAssociationsProvider extends ProductAssociation
         const associatedProductsResults = await Promise.all(allAssociatedProductPromises);
         const validAssociatedProductsResults = associatedProductsResults.filter(result => !!result).slice(0, maxNumberOfAssociations);
         for (const associatedProductResult of validAssociatedProductsResults) {
-          const resultItem = this.parseSingle(associatedProductResult.body);
-          if (resultItem) {
-            associatedProductSearchItems.push(resultItem);
-          }
+          associatedProductSearchItems.push(associatedProductResult.body);
         }
         return associatedProductSearchItems;
     }
 
 
-  protected parseSingle(body: ProductProjection) {
-    const identifier = { key: body.id };
-    const name = body.name[this.context.languageContext.locale] || body.id;
-    const slug = body.slug?.[this.context.languageContext.locale] || body.id;
-    const variants = [body.masterVariant, ...body.variants].map((variant) =>
-      this.parseVariant(variant, body)
-    );
-
-    const product = {
-      identifier,
-      name,
-      slug,
-      variants,
-    } satisfies ProductSearchResultItem;
-
-    return product;
-  }
-
-
   @Reactionary({
     cache: true,
     cacheTimeToLiveInSeconds: 300,
@@ -126,17 +102,17 @@ export class CommercetoolsProductAssociationsProvider extends ProductAssociation
   })
   public override async getAccessories(
     query: ProductAssociationsGetAccessoriesQuery
-  ): Promise<Result<ProductAssociation[]>> {
+  ): Promise<Result<ProductAssociationsFactoryOutput<TFactory>[]>> {
 
     const associatedProducts = await this.fetchAssociatedProductsFor(query.forProduct, query.numberOfAccessories || 4, 'reactionaryaccessories');
 
-    const result: ProductAssociation[] = associatedProducts.map(product => ({
-      associationIdentifier: {
-        key: `${query.forProduct.key}-accessory-${product.identifier.key}`
-      },
-      associationReturnType: 'productSearchResultItem',
-      product,
-    } satisfies ProductAssociation));
+    const result = associatedProducts.map((product) =>
+      this.factory.parseAssociation(this.context, {
+        sourceProductKey: query.forProduct.key,
+        relation: 'accessory',
+        product,
+      }),
+    );
 
     return success(result);
   }
@@ -149,16 +125,16 @@ export class CommercetoolsProductAssociationsProvider extends ProductAssociation
   })
   public override async getSpareparts(
     query: ProductAssociationsGetSparepartsQuery
-  ): Promise<Result<ProductAssociation[]>> {
+  ): Promise<Result<ProductAssociationsFactoryOutput<TFactory>[]>> {
     const associatedProducts = await this.fetchAssociatedProductsFor(query.forProduct, query.numberOfSpareparts || 4, 'reactionaryspareparts');
 
-    const result: ProductAssociation[] = associatedProducts.map(product => ({
-      associationIdentifier: {
-        key: `${query.forProduct.key}-sparepart-${product.identifier.key}`
-      },
-      associationReturnType: 'productSearchResultItem',
-      product,
-    } satisfies ProductAssociation));
+    const result = associatedProducts.map((product) =>
+      this.factory.parseAssociation(this.context, {
+        sourceProductKey: query.forProduct.key,
+        relation: 'sparepart',
+        product,
+      }),
+    );
 
     return success(result);
   }
@@ -171,59 +147,18 @@ export class CommercetoolsProductAssociationsProvider extends ProductAssociation
   })
   public override async getReplacements(
     query: ProductAssociationsGetReplacementsQuery
-  ): Promise<Result<ProductAssociation[]>> {
+  ): Promise<Result<ProductAssociationsFactoryOutput<TFactory>[]>> {
     const associatedProducts = await this.fetchAssociatedProductsFor(query.forProduct, query.numberOfReplacements || 4, 'reactionaryreplacements');
 
-    const result: ProductAssociation[] = associatedProducts.map(product => ({
-      associationIdentifier: {
-        key: `${query.forProduct.key}-replacement-${product.identifier.key}`
-      },
-      associationReturnType: 'productSearchResultItem',
-      product,
-    } satisfies ProductAssociation));
+    const result = associatedProducts.map((product) =>
+      this.factory.parseAssociation(this.context, {
+        sourceProductKey: query.forProduct.key,
+        relation: 'replacement',
+        product,
+      }),
+    );
 
     return success(result);
   }
 
-
-
-
-  protected parseVariant(
-    variant: CTProductVariant,
-    product: ProductProjection
-  ): ProductSearchResultItemVariant {
-    const sourceImage = variant.images?.[0];
-
-    const img = ImageSchema.parse({
-      sourceUrl: sourceImage?.url || '',
-      height: sourceImage?.dimensions.h || undefined,
-      width: sourceImage?.dimensions.w || undefined,
-      altText:
-        sourceImage?.label ||
-        product.name[this.context.languageContext.locale] ||
-        undefined,
-    });
-
-    const mappedOptions =
-      variant.attributes
-        ?.filter((x) => x.name === 'Color')
-        .map((opt) =>
-          ProductVariantOptionSchema.parse({
-            identifier: ProductOptionIdentifierSchema.parse({
-              key: opt.name,
-            } satisfies Partial<ProductOptionIdentifier>),
-            name: opt.value || '',
-          } satisfies Partial<ProductVariantOption>)
-        ) || [];
-
-    const mappedOption = mappedOptions?.[0];
-
-    return ProductSearchResultItemVariantSchema.parse({
-      variant: ProductVariantIdentifierSchema.parse({
-        sku: variant.sku || '',
-      } satisfies ProductVariantIdentifier),
-      image: img,
-      options: mappedOption,
-    } satisfies Partial<ProductSearchResultItemVariant>);
-  }
 }