@reactionary/source 0.0.52 → 0.2.16

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

@@ -0,0 +1,226 @@
+import type {
+  Cache,
+  Order,
+  OrderQueryById,
+  RequestContext,
+  Result,
+  NotFoundError,
+  IdentityIdentifier,
+  CostBreakDown,
+  Currency,
+  OrderItem,
+  CartItem,
+  ProductVariantIdentifier,
+  ItemCostBreakdown,
+  OrderStatus,
+  InventoryStatus,
+  OrderInventoryStatus,
+  PaymentMethodIdentifier,
+  PaymentInstruction,
+} from '@reactionary/core';
+import {
+  OrderProvider,
+  OrderQueryByIdSchema,
+  OrderSchema,
+  Reactionary,
+  success,
+  error,
+  ProductVariantIdentifierSchema,
+} from '@reactionary/core';
+import createDebug from 'debug';
+import type { MedusaAPI } from '../core/client.js';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+import { handleProviderError } from '../utils/medusa-helpers.js';
+import type { StoreOrder, StoreOrderLineItem, StorePaymentCollection } from '@medusajs/types';
+import { parseMedusaItemPrice, parseMedusaCostBreakdown } from '../utils/medusa-helpers.js'
+const debug = createDebug('reactionary:medusa:order');
+
+export class MedusaOrderProvider extends OrderProvider {
+  protected config: MedusaConfiguration;
+
+  constructor(
+    config: MedusaConfiguration,
+    cache: Cache,
+    context: RequestContext,
+    public medusaApi: MedusaAPI
+  ) {
+    super(cache, context);
+
+    this.config = config;
+  }
+
+  @Reactionary({
+    inputSchema: OrderQueryByIdSchema,
+    outputSchema: OrderSchema,
+  })
+  public async getById(payload: OrderQueryById): Promise<Result<Order, NotFoundError>> {
+    debug('getById', payload);
+
+    const medusa = await this.medusaApi.getClient();
+
+    try {
+      // TODO: Implement actual order retrieval logic
+      // const response = await medusa.store.order.retrieve(payload.order.key);
+      const response = await  medusa.store.order.retrieve(payload.order.key)
+
+      const order = this.parseSingle(response.order);
+
+      return success(order);
+
+    } catch (err) {
+      return handleProviderError('order', err);
+    }
+  }
+
+
+  /**
+   * Extension point to control the parsing of a single cart item price
+   * @param remoteItem
+   * @param currency
+   * @returns
+   */
+  protected parseItemPrice(
+    remoteItem: StoreOrderLineItem,
+    currency: Currency
+  ): ItemCostBreakdown {
+    return parseMedusaItemPrice(remoteItem, currency);
+  }
+
+  /**
+   * Extension point to control the parsing of the cost breakdown of a cart
+   * @param remote
+   * @returns
+   */
+  protected parseCostBreakdown(remote: StoreOrder): CostBreakDown {
+    return parseMedusaCostBreakdown(remote);
+  }
+
+  /**
+   * Extension point to control the parsing of a single cart item
+   * @param remoteItem
+   * @param currency
+   * @returns
+   */
+  protected parseOrderItem(
+    remoteItem: StoreOrderLineItem,
+    currency: Currency
+  ): OrderItem {
+    const item: OrderItem = {
+      identifier: {
+        key: remoteItem.id,
+      },
+      variant: ProductVariantIdentifierSchema.parse({
+        sku: remoteItem.variant_sku || '',
+      } satisfies ProductVariantIdentifier),
+      quantity: remoteItem.quantity || 1,
+      price: this.parseItemPrice(remoteItem, currency),
+      inventoryStatus: 'Allocated'
+    };
+    return item;
+  }
+
+  protected parsePaymentInstruction(remotePayment: StorePaymentCollection, order: StoreOrder) {
+      const paymentMethodIdentifier: PaymentMethodIdentifier = {
+        method: remotePayment.payment_providers?.[0]?.id || 'unknown',
+        name: remotePayment.payment_providers?.[0]?.id || 'unknown',
+        paymentProcessor: remotePayment.payment_providers?.[0]?.id || 'unknown',
+      };
+
+      let status: PaymentInstruction['status'] = 'pending';
+      switch (remotePayment.status) {
+        case 'not_paid':
+          status = 'pending';
+          break;
+        case 'awaiting':
+          status = 'pending';
+          break;
+        case 'authorized':
+          status = 'authorized';
+          break;
+        case 'partially_authorized':
+          status = 'pending';
+          break;
+        case 'canceled':
+          status = 'canceled';
+          break;
+        case 'failed':
+          status = 'canceled';
+          break;
+        case 'completed':
+          status = 'capture';
+          break;
+      }
+
+      const paymentData = remotePayment.payments?.[0].data || {};
+      const pi = {
+        identifier: {
+          key: remotePayment.id,
+        },
+        amount: {
+          value: remotePayment.amount,
+          currency: remotePayment.currency_code?.toUpperCase() as Currency,
+        },
+        paymentMethod: paymentMethodIdentifier,
+        protocolData: paymentData
+          ? Object.entries(paymentData).map(([key, value]) => ({
+              key,
+              value: String(value),
+            }))
+          : [],
+        status,
+      } satisfies PaymentInstruction;
+    return pi;
+  }
+
+
+
+
+  protected parseSingle(body: StoreOrder): Order {
+
+    const identifier = { key: body.id };
+    const userId: IdentityIdentifier = {
+      userId: body.customer_id || '',
+    }
+
+    const items = (body.items || []).map((item) => {
+      return this.parseOrderItem(item, body.currency_code.toUpperCase() as Currency);
+    });
+
+    const price = this.parseCostBreakdown(body);
+
+    let orderStatus: OrderStatus = 'AwaitingPayment'
+    if (body.status === 'draft') {
+      orderStatus = 'AwaitingPayment';
+    }
+    if (body.status === 'pending') {
+      orderStatus = 'ReleasedToFulfillment';
+    }
+    if (body.status === 'completed') {
+      orderStatus = 'Shipped';
+    }
+    if (body.status === 'canceled') {
+      orderStatus = 'Cancelled';
+    }
+
+    let inventoryStatus: OrderInventoryStatus = 'NotAllocated'
+    // Medusa does not have direct mapping for inventory status on orders
+    // This is a placeholder logic and may need to be adjusted based on actual requirements
+    if(body.fulfillment_status === "fulfilled") {
+      inventoryStatus = 'Allocated';
+    }
+
+    const paymentInstructions: PaymentInstruction[] =  body.payment_collections?.map( (pc) => {
+      return this.parsePaymentInstruction(pc, body);
+    }) || [];
+
+    return {
+      identifier,
+      userId,
+      items,
+      price,
+      orderStatus,
+      inventoryStatus,
+      paymentInstructions
+    } satisfies Order;
+  }
+}

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

@@ -0,0 +1,140 @@
+import type { StoreProductVariant } from '@medusajs/types';
+import {
+  PriceProvider,
+  PriceSchema,
+  CustomerPriceQuerySchema,
+  ListPriceQuerySchema,
+  Reactionary,
+  success,
+  type Cache,
+  type Currency,
+  type CustomerPriceQuery,
+  type ListPriceQuery,
+  type Price,
+  type RequestContext,
+  type PriceIdentifier,
+  type MonetaryAmount,
+  type Result
+} from '@reactionary/core';
+import createDebug from 'debug';
+import type z from 'zod';
+import type { MedusaAPI } from '../core/client.js';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+
+const debug = createDebug('reactionary:medusa:price');
+
+export class MedusaPriceProvider extends PriceProvider {
+  protected config: MedusaConfiguration;
+
+  constructor(
+    config: MedusaConfiguration,
+    cache: Cache,
+    context: RequestContext,
+    public medusaApi: MedusaAPI
+  ) {
+    super(cache, context);
+    this.config = config;
+  }
+
+  @Reactionary({
+    inputSchema: ListPriceQuerySchema,
+    outputSchema: PriceSchema,
+  })
+  public override async getListPrice(payload: ListPriceQuery): Promise<Result<Price>> {
+    const result = await this.getBySKU(payload);
+
+    return success(result);
+  }
+
+  @Reactionary({
+    inputSchema: CustomerPriceQuerySchema,
+    outputSchema: PriceSchema,
+  })
+  public override async getCustomerPrice(payload: CustomerPriceQuery): Promise<Result<Price>> {
+    const result = await this.getBySKU(payload);
+
+    return success(result);
+  }
+
+
+  protected async getBySKU(payload: ListPriceQuery | CustomerPriceQuery ): Promise<Price> {
+    const sku = payload.variant.sku;
+
+    if (debug.enabled) {
+      debug(`Fetching price for SKU: ${sku}`);
+    }
+
+    try {
+      const productForSKU = await this.medusaApi.resolveProductForSKU(payload.variant.sku);
+
+      const client = await this.medusaApi.getClient();
+      const product = (
+        await client.store.product.retrieve(
+          productForSKU.id || '',
+          { region_id: (await this.medusaApi.getActiveRegion()).id }
+        )
+      ).product;
+
+
+      const variant = product.variants?.find((v) => v.sku === sku);
+      if (!variant) {
+        if (debug.enabled) {
+          debug(
+            `Variant with SKU ${sku} not found in product ${product.id}`
+          );
+        }
+        return this.createEmptyPriceResult(sku);
+      }
+
+      // For simplicity, return the first matched product
+      return this.parseSingle(variant);
+    } catch (error) {
+      if (debug.enabled) {
+        debug(
+          `Error fetching price for SKU ${sku}: ${(error as Error).message}`
+        );
+      }
+      return this.createEmptyPriceResult(sku);
+    }
+  }
+
+  protected parseSingle(variant: StoreProductVariant): Price {
+    const identifier = {
+      variant: {
+        sku: variant.sku || '',
+      },
+    } satisfies PriceIdentifier;
+
+    // In Medusa v2, calculated_price contains the final price for the variant
+    // based on the region, currency, and any applicable price lists
+    const calculatedPrice = variant.calculated_price;
+
+    let unitPrice;
+    if (calculatedPrice) {
+      unitPrice = {
+        value: calculatedPrice.calculated_amount || 0,
+        currency: (calculatedPrice.currency_code?.toUpperCase() ||
+          this.context.languageContext.currencyCode) as Currency,
+      } satisfies MonetaryAmount;
+    } else {
+      // Fallback to empty price if no calculated price available
+      unitPrice = {
+        value: -1,
+        currency: this.context.languageContext.currencyCode as Currency,
+      } satisfies MonetaryAmount;
+    }
+
+    const result = {
+      identifier,
+      tieredPrices: [],
+      unitPrice
+    } satisfies Price;
+
+    return result;
+  }
+
+
+  protected override getResourceName(): string {
+    return 'price';
+  }
+}

package/providers/medusa/src/providers/product-search.provider.ts

@@ -0,0 +1,243 @@
+import {
+  ProductSearchProvider,
+  ProductSearchQueryByTermSchema,
+  type Cache,
+  type RequestContext,
+  type ProductSearchQueryByTerm,
+  type ProductSearchResult,
+  type ProductSearchResultItem,
+  ImageSchema,
+  ProductVariantIdentifierSchema,
+  type ProductVariantIdentifier,
+  ProductVariantOptionSchema,
+  type ProductVariantOption,
+  ProductOptionIdentifierSchema,
+  type ProductOptionIdentifier,
+  ProductSearchResultItemVariantSchema,
+  type ProductSearchResultItemVariant,
+  type FacetIdentifier,
+  type FacetValueIdentifier,
+  type ProductSearchResultFacet,
+  type ProductSearchResultFacetValue,
+  Reactionary,
+  ProductSearchResultSchema,
+  type ProductSearchQueryCreateNavigationFilter,
+  FacetValueIdentifierSchema,
+  FacetIdentifierSchema,
+  type Result,
+  success,
+} from '@reactionary/core';
+import createDebug from 'debug';
+import type z from 'zod';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+import type { MedusaAPI } from '../core/client.js';
+import type {
+  StoreProduct,
+  StoreProductCategory,
+  StoreProductListResponse,
+  StoreProductVariant,
+} from '@medusajs/types';
+
+const debug = createDebug('reactionary:medusa:search');
+
+export class MedusaSearchProvider extends ProductSearchProvider {
+  protected config: MedusaConfiguration;
+
+  constructor(
+    config: MedusaConfiguration,
+    cache: Cache,
+    context: RequestContext,
+    public medusaApi: MedusaAPI
+  ) {
+    super(cache, context);
+    this.config = config;
+  }
+
+  protected async resolveCategoryIdByExternalId(
+    externalId: string
+  ): Promise<StoreProductCategory | null> {
+    const sdk = await this.medusaApi.getClient();
+    let offset = 0;
+    const limit = 50;
+    let candidate: StoreProductCategory | undefined = undefined;
+    while (true) {
+      try {
+        const categoryResult = await sdk.store.category.list({
+          offset,
+          limit,
+        });
+
+        if (categoryResult.product_categories.length === 0) {
+          break;
+        }
+
+        candidate = categoryResult.product_categories.find(
+          (cat) => cat.metadata?.['external_id'] === externalId
+        );
+        if (candidate) {
+          break;
+        }
+        offset += limit;
+      } catch (error) {
+        throw new Error(
+          'Category not found ' + externalId + ' due to error: ' + error
+        );
+        break;
+      }
+    }
+    return candidate || null;
+  }
+
+  @Reactionary({
+    inputSchema: ProductSearchQueryByTermSchema,
+    outputSchema: ProductSearchResultSchema,
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: true
+  })
+  public override async queryByTerm(
+    payload: ProductSearchQueryByTerm
+  ): Promise<Result<ProductSearchResult>> {
+    const client = await this.medusaApi.getClient();
+
+    let categoryIdToFind: string | null = null;
+    if (payload.search.categoryFilter?.key) {
+      debug(
+        `Resolving category filter for key: ${payload.search.categoryFilter.key}`
+      );
+
+      const category = await this.resolveCategoryIdByExternalId(
+        payload.search.categoryFilter.key
+      );
+      if (category) {
+        categoryIdToFind = category.id;
+        debug(
+          `Resolved category filter key ${payload.search.categoryFilter.key} to id: ${categoryIdToFind}`
+        );
+      } else {
+        debug(
+          `Could not resolve category filter for key: ${payload.search.categoryFilter.key}`
+        );
+      }
+    }
+    const finalSearch = (payload.search.term || '').trim().replace('*', '');
+    const response = await client.store.product.list({
+      q: finalSearch,
+      ...(categoryIdToFind ? { category_id: categoryIdToFind } : {}),
+      limit: payload.search.paginationOptions.pageSize,
+      offset:
+        (payload.search.paginationOptions.pageNumber - 1) *
+        payload.search.paginationOptions.pageSize,
+    });
+
+    const result = this.parsePaginatedResult(response) as ProductSearchResult;
+    if (debug.enabled) {
+      debug(
+        `Search for term "${payload.search.term}" returned ${response.products.length} products (page ${payload.search.paginationOptions.pageNumber} of ${result.totalPages})`
+      );
+    }
+
+    // Set result metadata
+    result.identifier = {
+      ...payload.search,
+    };
+
+    return success(result);
+  }
+
+  protected parsePaginatedResult(remote: StoreProductListResponse) {
+    // Parse facets
+    // no facets available from Medusa at the moment
+
+    const products: ProductSearchResultItem[] = remote.products.map((p) =>
+      this.parseSingle(p)
+    );
+
+    const result = {
+      identifier: {
+        facets: [],
+        filters: [],
+        paginationOptions: {
+          pageNumber: 1,
+          pageSize: 0,
+        },
+        term: '',
+      },
+      pageNumber: (Math.ceil(remote.offset / remote.limit) || 0) + 1,
+      pageSize: remote.limit,
+      totalCount: remote.count,
+      totalPages: Math.ceil(remote.count / remote.limit || 0) + 1,
+      items: products,
+      facets: [],
+    } satisfies ProductSearchResult;
+
+    (result as ProductSearchResult).facets = [];
+    return result;
+  }
+
+  protected parseSingle(_body: StoreProduct): ProductSearchResultItem {
+    const heroVariant = _body.variants?.[0];
+    const identifier = { key: _body.id };
+    const slug = _body.handle;
+    const name = heroVariant?.title || _body.title;
+    const variants = [];
+    if (heroVariant) {
+      variants.push(this.parseVariant(heroVariant, _body));
+    }
+
+    const result = {
+      identifier,
+      name,
+      slug,
+      variants,
+    } satisfies ProductSearchResultItem;
+
+    return result;
+  }
+
+  protected parseVariant(
+    variant: StoreProductVariant,
+    product: StoreProduct
+  ): ProductSearchResultItemVariant {
+    const img = ImageSchema.parse({
+      sourceUrl: product.images?.[0].url ?? '',
+      altText: product.title || undefined,
+    });
+
+    return ProductSearchResultItemVariantSchema.parse({
+      variant: ProductVariantIdentifierSchema.parse({
+        sku: variant.sku || '',
+      } satisfies ProductVariantIdentifier),
+      image: img,
+    } satisfies Partial<ProductSearchResultItemVariant>);
+  }
+
+  public override async createCategoryNavigationFilter(
+    payload: ProductSearchQueryCreateNavigationFilter
+  ): Promise<Result<FacetValueIdentifier>> {
+    const facetIdentifier = FacetIdentifierSchema.parse({
+      key: 'categories',
+    });
+    const facetValueIdentifier = FacetValueIdentifierSchema.parse({
+      facet: facetIdentifier,
+      key: payload.categoryPath[payload.categoryPath.length - 1].identifier.key,
+    });
+
+    return success(facetValueIdentifier);
+  }
+
+  protected override parseFacetValue(
+    facetValueIdentifier: FacetValueIdentifier,
+    label: string,
+    count: number
+  ): ProductSearchResultFacetValue {
+    throw new Error('Method not implemented.');
+  }
+  protected override parseFacet(
+    facetIdentifier: FacetIdentifier,
+    facetValue: unknown
+  ): ProductSearchResultFacet {
+    throw new Error('Method not implemented.');
+  }
+}