@reactionary/source 0.0.52 → 0.2.16

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

@@ -0,0 +1,137 @@
+import {
+  type Identity,
+  type IdentityMutationLogin,
+  type IdentityMutationLogout,
+  type IdentityMutationRegister,
+  type IdentityQuerySelf,
+  type RequestContext,
+  type Cache,
+  IdentityProvider,
+  Reactionary,
+  IdentityQuerySelfSchema,
+  IdentitySchema,
+  IdentityMutationRegisterSchema,
+  IdentityMutationLoginSchema,
+  IdentityMutationLogoutSchema,
+  type AnonymousIdentity,
+  type RegisteredIdentity,
+  type Result,
+  success,
+} from '@reactionary/core';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+import type z from 'zod';
+import type { MedusaAPI } from '../core/client.js';
+import createDebug from 'debug';
+
+const debug = createDebug('reactionary:medusa:identity');
+
+export class MedusaIdentityProvider extends IdentityProvider {
+  protected config: MedusaConfiguration;
+  protected medusaApi: MedusaAPI;
+
+  constructor(
+    config: MedusaConfiguration,
+    cache: Cache,
+    context: RequestContext,
+    medusaApi: MedusaAPI
+  ) {
+    super(cache, context);
+
+    this.config = config;
+    this.medusaApi = medusaApi;
+  }
+
+  protected createAnonymousIdentity(): AnonymousIdentity {
+    return {
+      type: 'Anonymous',
+    };
+  }
+
+  @Reactionary({
+    inputSchema: IdentityQuerySelfSchema,
+    outputSchema: IdentitySchema,
+  })
+  public override async getSelf(
+    _payload: IdentityQuerySelf
+  ): Promise<Result<Identity>> {
+    try {
+      const medusaClient = await this.medusaApi.getClient();
+      const token = await medusaClient.client.getToken();
+
+      if (!token) {
+        debug('No active session token found, returning anonymous identity');
+        return success(this.createAnonymousIdentity());
+      }
+
+      // Try to fetch customer details to verify authentication
+      const customerResponse = await medusaClient.store.customer.retrieve();
+
+      if (customerResponse.customer) {
+        debug('Customer authenticated:', customerResponse.customer.email);
+        return success({
+          id: {
+            userId: customerResponse.customer.id,
+          },
+          type: 'Registered',
+        } satisfies RegisteredIdentity);
+      }
+
+      return success(this.createAnonymousIdentity());
+    } catch (error) {
+      debug('getSelf failed, returning anonymous identity:', error);
+      return success(this.createAnonymousIdentity());
+    }
+  }
+
+  @Reactionary({
+    inputSchema: IdentityMutationLoginSchema,
+    outputSchema: IdentitySchema,
+  })
+  public override async login(payload: IdentityMutationLogin): Promise<Result<Identity>> {
+    debug('Attempting login for user:', payload.username);
+    const identity = await this.medusaApi.login(
+      payload.username,
+      payload.password,
+      this.context
+    ) satisfies Identity;
+
+    return success(identity);
+  }
+
+  @Reactionary({
+    inputSchema: IdentityMutationLogoutSchema,
+    outputSchema: IdentitySchema,
+  })
+  public override async logout(_payload: IdentityMutationLogout): Promise<Result<Identity>> {
+    debug('Logging out user');
+    const identity = await this.medusaApi.logout(this.context);
+
+    return success(identity);
+  }
+
+  @Reactionary({
+    inputSchema: IdentityMutationRegisterSchema,
+    outputSchema: IdentitySchema,
+  })
+  public override async register(
+    payload: IdentityMutationRegister
+  ): Promise<Result<Identity>> {
+    debug('Registering new user:', payload.username);
+
+    // Extract first and last name from username or use defaults
+    // In a real implementation, you might want to add firstName/lastName to the schema
+    const nameParts = payload.username.split('.');
+    const firstName = nameParts[0] || 'User';
+    const lastName = nameParts.slice(1).join(' ') || 'Account';
+
+    const identity = await this.medusaApi.register(
+      payload.username, // Using username as email
+      payload.password,
+      firstName,
+      lastName,
+      this.context
+    );
+
+    return success(identity);
+  }
+}

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

@@ -0,0 +1,173 @@
+import {
+  type Inventory,
+  type InventoryQueryBySKU,
+  type RequestContext,
+  type Cache,
+  InventoryProvider,
+  InventorySchema,
+  InventoryQueryBySKUSchema,
+  Reactionary,
+  type InventoryIdentifier,
+  type InventoryStatus,
+  type NotFoundError,
+  type Result,
+  success,
+} from '@reactionary/core';
+import type z from 'zod';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+import { MedusaAdminAPI, type MedusaAPI } from '../core/client.js';
+import createDebug from 'debug';
+
+const debug = createDebug('reactionary:medusa:inventory');
+
+export class MedusaInventoryProvider extends InventoryProvider {
+  protected config: MedusaConfiguration;
+
+  constructor(
+    config: MedusaConfiguration,
+    cache: Cache,
+    context: RequestContext,
+    public medusaApi: MedusaAPI
+  ) {
+    super(cache, context);
+    this.config = config;
+  }
+
+  @Reactionary({
+    inputSchema: InventoryQueryBySKUSchema,
+    outputSchema: InventorySchema,
+  })
+  public override async getBySKU(payload: InventoryQueryBySKU): Promise<Result<Inventory, NotFoundError>> {
+    const sku = payload.variant.sku;
+    const fulfillmentCenterKey = payload.fulfilmentCenter.key;
+
+    if (debug.enabled) {
+      debug(`Fetching inventory for SKU: ${sku}, fulfillment center: ${fulfillmentCenterKey}`);
+    }
+
+    try {
+      const adminClient = await (new MedusaAdminAPI(this.config, this.context).getClient());
+
+      // Get inventory items for this variant
+      const inventoryResponse = await adminClient.admin.inventoryItem.list({
+        sku: [sku],
+        limit: 1,
+        offset: 0
+      })
+
+      if (!inventoryResponse.inventory_items || inventoryResponse.inventory_items.length === 0) {
+        if (debug.enabled) {
+          debug(`No inventory items found for SKU: ${sku}`);
+        }
+        return success(this.createEmptyInventoryResult(sku, fulfillmentCenterKey));
+      }
+
+      const inventoryItem = inventoryResponse.inventory_items[0];
+
+      // Get inventory levels for this item and location
+      // In Medusa, we need to find the stock location that matches our fulfillment center key
+      const locationsResponse = await adminClient.admin.stockLocation.list({
+        name: fulfillmentCenterKey,
+        limit: 1,
+        offset: 0
+      });
+
+      let quantity = 0;
+      let locationFound = false;
+
+      if (locationsResponse.stock_locations && locationsResponse.stock_locations.length > 0) {
+        const location = locationsResponse.stock_locations[0];
+        locationFound = true;
+
+        // Get inventory level for this item at this location
+        const levelsResponse = await adminClient.admin.inventoryItem.listLevels(inventoryItem.id, {
+          location_id: [location.id],
+        });
+
+        if (levelsResponse.inventory_levels && levelsResponse.inventory_levels.length > 0) {
+          const level = levelsResponse.inventory_levels[0];
+          quantity = level.stocked_quantity - level.reserved_quantity;
+        }
+      }
+
+      if (!locationFound) {
+        if (debug.enabled) {
+          debug(`No stock location found with name: ${fulfillmentCenterKey}`);
+        }
+        return success(this.createEmptyInventoryResult(sku, fulfillmentCenterKey));
+      }
+
+      return success(this.parseSingle({
+        sku: payload.variant.sku,
+        fulfillmentCenterKey,
+        quantity,
+        inventoryItemId: inventoryItem.id,
+      }));
+
+    } catch (error) {
+      if (debug.enabled) {
+        debug(`Error fetching inventory for SKU: ${sku}`, error);
+      }
+      return success(this.createEmptyInventoryResult(sku, fulfillmentCenterKey));
+    }
+  }
+
+  protected parseSingle(_body: unknown): Inventory {
+    const { sku, fulfillmentCenterKey, quantity } = _body as {
+      sku: string;
+      fulfillmentCenterKey: string;
+      quantity: number;
+      inventoryItemId: string;
+    };
+
+    const identifier = {
+      variant: {
+        sku,
+      },
+      fulfillmentCenter: {
+        key: fulfillmentCenterKey,
+      },
+    } satisfies InventoryIdentifier;
+
+    let status: InventoryStatus = 'outOfStock';
+    if (quantity > 0) {
+      status = 'inStock';
+    }
+
+    const result = {
+      identifier,
+      quantity,
+      status
+    } satisfies Inventory;
+
+    return result;
+  }
+
+  /**
+   * Utility function to create an empty inventory result.
+   * This is used when no inventory is found for a given SKU + fulfillment center combination.
+   * @param sku
+   * @param fulfillmentCenterKey
+   * @returns
+   */
+  protected createEmptyInventoryResult(sku: string, fulfillmentCenterKey: string): Inventory {
+    const identifier = {
+      variant: { sku },
+      fulfillmentCenter: { key: fulfillmentCenterKey },
+    } satisfies InventoryIdentifier;
+
+    const quantity = 0;
+    const status = 'outOfStock';
+    const result = {
+      identifier,
+      quantity,
+      status
+    } satisfies Inventory;
+
+    return result;
+  }
+
+  protected override getResourceName(): string {
+    return 'inventory';
+  }
+}

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

@@ -0,0 +1,202 @@
+import type {
+  RequestContext,
+  Cache,
+  OrderSearchQueryByTerm,
+  OrderSearchResult,
+  Result,
+  OrderStatus,
+  Address,
+  IdentityIdentifier,
+  MonetaryAmount,
+  Currency,
+  OrderSearchResultItem,
+  OrderSearchIdentifier,
+  AddressIdentifier,
+  OrderInventoryStatus,
+} from '@reactionary/core';
+import {
+  AddressIdentifierSchema,
+  OrderSearchProvider,
+  OrderSearchQueryByTermSchema,
+  OrderSearchResultSchema,
+  Reactionary,
+  success,
+} from '@reactionary/core';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+import type { MedusaAPI } from '../core/client.js';
+import createDebug from 'debug';
+import type { OrderStatus as MedusaOrderStatus, StoreOrder, StoreOrderAddress,  StoreOrderListResponse } from '@medusajs/types';
+
+const debug = createDebug('reactionary:medusa:order-search');
+
+export class MedusaOrderSearchProvider extends OrderSearchProvider {
+  protected config: MedusaConfiguration;
+
+  constructor(
+    config: MedusaConfiguration,
+    cache: Cache,
+    context: RequestContext,
+    public medusaApi: MedusaAPI
+  ) {
+    super(cache, context);
+
+    this.config = config;
+
+  }
+
+  @Reactionary({
+    inputSchema: OrderSearchQueryByTermSchema,
+    outputSchema: OrderSearchResultSchema,
+  })
+  public async queryByTerm(payload: OrderSearchQueryByTerm): Promise<Result<OrderSearchResult>> {
+    debug('queryByTerm', payload);
+
+    const medusa = await this.medusaApi.getClient();
+
+    if (payload.search.term) {
+      debug('Searching orders by term is not supported in Medusa');
+    }
+
+    if (payload.search.partNumber) {
+      debug('Searching orders by part number is not supported in Medusa');
+    }
+
+    if (payload.search.startDate) {
+      debug('Searching orders by start date is not supported in Medusa');
+    }
+    if (payload.search.endDate) {
+      debug('Searching orders by end date is not supported in Medusa');
+    }
+    /*
+    if (payload.search.user && payload.search.user.userId) {
+      debug('Searching orders by customer ID is not supported in Medusa');
+    } */
+    const statusFilter: MedusaOrderStatus[] = (payload.search.orderStatus ?? []).map((status) => {
+      let retStatus: MedusaOrderStatus = 'draft';
+      if (status === 'AwaitingPayment') {
+        retStatus = 'draft';
+      }
+      if (status === 'ReleasedToFulfillment') {
+        retStatus = 'pending';
+      }
+      if (status === 'Shipped') {
+        retStatus = 'completed';
+      }
+      if (status === 'Cancelled') {
+        retStatus = 'canceled';
+      }
+      return retStatus;
+    });
+
+
+    const response = await medusa.store.order.list({
+      status: statusFilter,
+      limit: payload.search.paginationOptions.pageSize,
+      offset:
+        (payload.search.paginationOptions.pageNumber - 1) *
+        payload.search.paginationOptions.pageSize,
+
+    });
+
+    const result = this.parsePaginatedResult(response, payload) as OrderSearchResult;
+    if (debug.enabled) {
+      debug(
+        `Search for term "${payload.search.term}" returned ${response.orders.length} orders (page ${payload.search.paginationOptions.pageNumber} of ${result.totalPages})`
+      );
+    }
+
+    return success(result);
+  }
+
+  protected composeAddressFromStoreAddress(storeAddress: StoreOrderAddress): Address {
+    return {
+      identifier: AddressIdentifierSchema.parse({
+        nickName: storeAddress.id,
+      } satisfies AddressIdentifier),
+      firstName: storeAddress.first_name || '',
+      lastName: storeAddress.last_name || '',
+      streetAddress: storeAddress.address_1 || '',
+      streetNumber: storeAddress.address_2 || '',
+      city: storeAddress.city || '',
+      postalCode: storeAddress.postal_code || '',
+      countryCode: storeAddress.country_code || '',
+      region: '',
+    };
+  }
+
+
+
+  protected parseSingle(body: StoreOrder) {
+    const identifier = { key: body.id };
+    const userId: IdentityIdentifier = {
+      userId: body.customer_id || '',
+    };
+    const customerName = `${body.billing_address?.first_name} ${body.billing_address?.last_name}`;
+    const shippingAddress = this.composeAddressFromStoreAddress(body.shipping_address!);
+    const orderDate = new Date(body.created_at).toISOString();
+
+    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 totalAmount: MonetaryAmount = {
+      currency: body.currency_code.toUpperCase() as Currency,
+      value: body.total ? body.total : 0
+    };
+
+    const order = {
+      identifier,
+      userId,
+      customerName,
+      shippingAddress,
+      orderDate,
+      orderStatus,
+      inventoryStatus,
+      totalAmount
+    } satisfies OrderSearchResultItem;
+
+    return order;
+  }
+
+  protected parsePaginatedResult(
+    body: StoreOrderListResponse,
+    query: OrderSearchQueryByTerm
+  ) {
+    const identifier = {
+      ...query.search,
+    } satisfies OrderSearchIdentifier;
+
+    const orders: OrderSearchResultItem[] = body.orders.map((o) => {
+      return this.parseSingle(o);
+    })
+
+    const result = {
+      identifier,
+      pageNumber: (Math.ceil(body.offset / body.limit) || 0) + 1,
+      pageSize: body.limit,
+      totalCount: body.count,
+      totalPages: Math.ceil(body.count / body.limit || 0) + 1,
+      items: orders,
+    } satisfies OrderSearchResult;
+
+    return result;
+  }
+
+
+}