@reactionary/source 0.3.18 → 0.6.2

package/providers/medusa/src/factories/checkout/checkout.factory.ts

@@ -0,0 +1,50 @@
+import type {
+  AnyCheckoutSchema,
+  AnyPaymentMethodSchema,
+  AnyShippingMethodSchema,
+  CheckoutFactory,
+  CheckoutSchema,
+  PaymentMethodSchema,
+  RequestContext,
+  ShippingMethodSchema,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class MedusaCheckoutFactory<
+  TCheckoutSchema extends AnyCheckoutSchema = typeof CheckoutSchema,
+  TShippingMethodSchema extends AnyShippingMethodSchema = typeof ShippingMethodSchema,
+  TPaymentMethodSchema extends AnyPaymentMethodSchema = typeof PaymentMethodSchema,
+> implements CheckoutFactory<TCheckoutSchema, TShippingMethodSchema, TPaymentMethodSchema>
+{
+  public readonly checkoutSchema: TCheckoutSchema;
+  public readonly shippingMethodSchema: TShippingMethodSchema;
+  public readonly paymentMethodSchema: TPaymentMethodSchema;
+
+  constructor(
+    checkoutSchema: TCheckoutSchema,
+    shippingMethodSchema: TShippingMethodSchema,
+    paymentMethodSchema: TPaymentMethodSchema,
+  ) {
+    this.checkoutSchema = checkoutSchema;
+    this.shippingMethodSchema = shippingMethodSchema;
+    this.paymentMethodSchema = paymentMethodSchema;
+  }
+
+  public parseCheckout(_context: RequestContext, data: unknown): z.output<TCheckoutSchema> {
+    return this.checkoutSchema.parse(data);
+  }
+
+  public parseShippingMethod(
+    _context: RequestContext,
+    data: unknown,
+  ): z.output<TShippingMethodSchema> {
+    return this.shippingMethodSchema.parse(data);
+  }
+
+  public parsePaymentMethod(
+    _context: RequestContext,
+    data: unknown,
+  ): z.output<TPaymentMethodSchema> {
+    return this.paymentMethodSchema.parse(data);
+  }
+}

package/providers/medusa/src/factories/identity/identity.factory.ts

@@ -0,0 +1,22 @@
+import type {
+  AnyIdentitySchema,
+  IdentityFactory,
+  IdentitySchema,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class MedusaIdentityFactory<
+  TIdentitySchema extends AnyIdentitySchema = typeof IdentitySchema,
+> implements IdentityFactory<TIdentitySchema>
+{
+  public readonly identitySchema: TIdentitySchema;
+
+  constructor(identitySchema: TIdentitySchema) {
+    this.identitySchema = identitySchema;
+  }
+
+  public parseIdentity(_context: RequestContext, data: unknown): z.output<TIdentitySchema> {
+    return this.identitySchema.parse(data);
+  }
+}

package/providers/medusa/src/factories/index.ts

@@ -0,0 +1,12 @@
+export * from './cart/cart.factory.js';
+export * from './category/category.factory.js';
+export * from './checkout/checkout.factory.js';
+export * from './identity/identity.factory.js';
+export * from './inventory/inventory.factory.js';
+export * from './order/order.factory.js';
+export * from './order-search/order-search.factory.js';
+export * from './price/price.factory.js';
+export * from './product/product.factory.js';
+export * from './product-associations/product-associations.factory.js';
+export * from './product-search/product-search.factory.js';
+export * from './profile/profile.factory.js';

package/providers/medusa/src/factories/inventory/inventory.factory.ts

@@ -0,0 +1,25 @@
+import type {
+  AnyInventorySchema,
+  InventoryFactory,
+  InventorySchema,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class MedusaInventoryFactory<
+  TInventorySchema extends AnyInventorySchema = typeof InventorySchema,
+> implements InventoryFactory<TInventorySchema>
+{
+  public readonly inventorySchema: TInventorySchema;
+
+  constructor(inventorySchema: TInventorySchema) {
+    this.inventorySchema = inventorySchema;
+  }
+
+  public parseInventory(
+    _context: RequestContext,
+    data: unknown,
+  ): z.output<TInventorySchema> {
+    return this.inventorySchema.parse(data);
+  }
+}

package/providers/medusa/src/factories/order/order.factory.ts

@@ -0,0 +1,22 @@
+import type {
+  AnyOrderSchema,
+  OrderFactory,
+  OrderSchema,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class MedusaOrderFactory<
+  TOrderSchema extends AnyOrderSchema = typeof OrderSchema,
+> implements OrderFactory<TOrderSchema>
+{
+  public readonly orderSchema: TOrderSchema;
+
+  constructor(orderSchema: TOrderSchema) {
+    this.orderSchema = orderSchema;
+  }
+
+  public parseOrder(_context: RequestContext, data: unknown): z.output<TOrderSchema> {
+    return this.orderSchema.parse(data);
+  }
+}

package/providers/medusa/src/factories/order-search/order-search.factory.ts

@@ -0,0 +1,27 @@
+import type {
+  AnyOrderSearchResultSchema,
+  OrderSearchFactory,
+  OrderSearchQueryByTerm,
+  OrderSearchResultSchema,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class MedusaOrderSearchFactory<
+  TOrderSearchResultSchema extends AnyOrderSearchResultSchema = typeof OrderSearchResultSchema,
+> implements OrderSearchFactory<TOrderSearchResultSchema>
+{
+  public readonly orderSearchResultSchema: TOrderSearchResultSchema;
+
+  constructor(orderSearchResultSchema: TOrderSearchResultSchema) {
+    this.orderSearchResultSchema = orderSearchResultSchema;
+  }
+
+  public parseOrderSearchResult(
+    _context: RequestContext,
+    data: unknown,
+    _query: OrderSearchQueryByTerm,
+  ): z.output<TOrderSearchResultSchema> {
+    return this.orderSearchResultSchema.parse(data);
+  }
+}

package/providers/medusa/src/factories/price/price.factory.ts

@@ -0,0 +1,26 @@
+import type {
+  AnyPriceSchema,
+  PriceFactory,
+  PriceSchema,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class MedusaPriceFactory<
+  TPriceSchema extends AnyPriceSchema = typeof PriceSchema,
+> implements PriceFactory<TPriceSchema>
+{
+  public readonly priceSchema: TPriceSchema;
+
+  constructor(priceSchema: TPriceSchema) {
+    this.priceSchema = priceSchema;
+  }
+
+  public parsePrice(
+    _context: RequestContext,
+    data: unknown,
+    _options?: { includeDiscounts: boolean },
+  ): z.output<TPriceSchema> {
+    return this.priceSchema.parse(data);
+  }
+}

package/providers/medusa/src/factories/product/product.factory.ts

@@ -0,0 +1,22 @@
+import type {
+  AnyProductSchema,
+  ProductFactory,
+  ProductSchema,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class MedusaProductFactory<
+  TProductSchema extends AnyProductSchema = typeof ProductSchema,
+> implements ProductFactory<TProductSchema>
+{
+  public readonly productSchema: TProductSchema;
+
+  constructor(productSchema: TProductSchema) {
+    this.productSchema = productSchema;
+  }
+
+  public parseProduct(_context: RequestContext, data: unknown): z.output<TProductSchema> {
+    return this.productSchema.parse(data);
+  }
+}

package/providers/medusa/src/factories/product-associations/product-associations.factory.ts

@@ -0,0 +1,25 @@
+import type {
+  AnyProductAssociationSchema,
+  ProductAssociationSchema,
+  ProductAssociationsFactory,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class MedusaProductAssociationsFactory<
+  TProductAssociationSchema extends AnyProductAssociationSchema = typeof ProductAssociationSchema,
+> implements ProductAssociationsFactory<TProductAssociationSchema>
+{
+  public readonly productAssociationSchema: TProductAssociationSchema;
+
+  constructor(productAssociationSchema: TProductAssociationSchema) {
+    this.productAssociationSchema = productAssociationSchema;
+  }
+
+  public parseAssociation(
+    _context: RequestContext,
+    data: unknown,
+  ): z.output<TProductAssociationSchema> {
+    return this.productAssociationSchema.parse(data);
+  }
+}

package/providers/medusa/src/factories/product-search/product-search.factory.ts

@@ -0,0 +1,27 @@
+import type {
+  AnyProductSearchResultSchema,
+  ProductSearchFactory,
+  ProductSearchQueryByTerm,
+  ProductSearchResultSchema,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class MedusaProductSearchFactory<
+  TProductSearchResultSchema extends AnyProductSearchResultSchema = typeof ProductSearchResultSchema,
+> implements ProductSearchFactory<TProductSearchResultSchema>
+{
+  public readonly productSearchResultSchema: TProductSearchResultSchema;
+
+  constructor(productSearchResultSchema: TProductSearchResultSchema) {
+    this.productSearchResultSchema = productSearchResultSchema;
+  }
+
+  public parseSearchResult(
+    _context: RequestContext,
+    data: unknown,
+    _query: ProductSearchQueryByTerm,
+  ): z.output<TProductSearchResultSchema> {
+    return this.productSearchResultSchema.parse(data);
+  }
+}

package/providers/medusa/src/factories/profile/profile.factory.ts

@@ -0,0 +1,22 @@
+import type {
+  AnyProfileSchema,
+  ProfileFactory,
+  ProfileSchema,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class MedusaProfileFactory<
+  TProfileSchema extends AnyProfileSchema = typeof ProfileSchema,
+> implements ProfileFactory<TProfileSchema>
+{
+  public readonly profileSchema: TProfileSchema;
+
+  constructor(profileSchema: TProfileSchema) {
+    this.profileSchema = profileSchema;
+  }
+
+  public parseProfile(_context: RequestContext, data: unknown): z.output<TProfileSchema> {
+    return this.profileSchema.parse(data);
+  }
+}

package/providers/medusa/src/index.ts

@@ -2,7 +2,9 @@ export * from './schema/configuration.schema.js';
 export * from './schema/medusa.schema.js';
 export * from './schema/capabilities.schema.js';
 export * from './core/initialize.js';
+export * from './core/initialize.types.js';
 export * from './core/client.js';
+export * from './factories/index.js';
 export * from './providers/cart.provider.js';
 export * from './providers/identity.provider.js';
 export * from './providers/inventory.provider.js';

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

@@ -3,6 +3,10 @@ import type {
   Cart,
   CartIdentifier,
   CartItem,
+  CartFactory,
+  CartFactoryCartOutput,
+  CartFactoryIdentifierOutput,
+  CartFactoryWithOutput,
   CartMutationApplyCoupon,
   CartMutationChangeCurrency,
   CartMutationDeleteCart,
@@ -49,11 +53,18 @@ import {
   parseMedusaItemPrice,
 } from '../utils/medusa-helpers.js';
 import type { StoreAddCartLineItem, StoreCart, StoreCartAddPromotion, StoreCartLineItem, StoreCartRemovePromotion, StoreCartResponse, StoreCreateCart, StoreProduct, StoreUpdateCart, StoreUpdateCartLineItem } from '@medusajs/types';
+import type { MedusaCartFactory } from '../factories/cart/cart.factory.js';
 
 const debug = createDebug('reactionary:medusa:cart');
 
-export class MedusaCartProvider extends CartProvider {
+export class MedusaCartProvider<
+  TFactory extends CartFactory = MedusaCartFactory,
+> extends CartProvider<
+  CartFactoryCartOutput<TFactory>,
+  CartFactoryIdentifierOutput<TFactory>
+> {
   protected config: MedusaConfiguration;
+  protected factory: CartFactoryWithOutput<TFactory>;
   /**
    * This controls which fields are always included when fetching a cart
    * You can override this in a subclass to add more fields as needed.
@@ -66,10 +77,12 @@ export class MedusaCartProvider extends CartProvider {
     config: MedusaConfiguration,
     cache: Cache,
     context: RequestContext,
-    public medusaApi: MedusaAPI
+    public medusaApi: MedusaAPI,
+    factory: CartFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
     this.config = config;
+    this.factory = factory;
   }
 
   @Reactionary({
@@ -78,7 +91,7 @@ export class MedusaCartProvider extends CartProvider {
   })
   public override async getById(
     payload: CartQueryById
-  ): Promise<Result<Cart, NotFoundError>> {
+  ): Promise<Result<CartFactoryCartOutput<TFactory>, NotFoundError>> {
     try {
       const client = await this.getClient();
       const medusaId = payload.cart as MedusaCartIdentifier;
@@ -132,7 +145,7 @@ export class MedusaCartProvider extends CartProvider {
   })
   public override async add(
     payload: CartMutationItemAdd
-  ): Promise<Result<Cart>> {
+  ): Promise<Result<CartFactoryCartOutput<TFactory>>> {
     try {
       const client = await this.getClient();
 
@@ -190,7 +203,7 @@ export class MedusaCartProvider extends CartProvider {
   })
   public override async remove(
     payload: CartMutationItemRemove
-  ): Promise<Result<Cart>> {
+  ): Promise<Result<CartFactoryCartOutput<TFactory>>> {
     try {
       const client = await this.getClient();
       const medusaId = payload.cart as MedusaCartIdentifier;
@@ -231,7 +244,7 @@ export class MedusaCartProvider extends CartProvider {
   })
   public override async changeQuantity(
     payload: CartMutationItemQuantityChange
-  ): Promise<Result<Cart>> {
+  ): Promise<Result<CartFactoryCartOutput<TFactory>>> {
     if (payload.quantity < 1) {
       throw new Error(
         'Changing quantity to 0 is not allowed. Use the remove call instead.'
@@ -267,7 +280,7 @@ export class MedusaCartProvider extends CartProvider {
     outputSchema: CartIdentifierSchema,
   })
   public override async getActiveCartId(): Promise<
-    Result<CartIdentifier, NotFoundError>
+    Result<CartFactoryIdentifierOutput<TFactory>, NotFoundError>
   > {
     try {
       const client = await this.getClient();
@@ -278,12 +291,10 @@ export class MedusaCartProvider extends CartProvider {
       if (activeCartId) {
         try {
           await client.store.cart.retrieve(activeCartId);
-          return success(
-            MedusaCartIdentifierSchema.parse({
-              key: activeCartId,
-              region_id: (await this.medusaApi.getActiveRegion()).id,
-            })
-          );
+          return success(this.factory.parseCartIdentifier(this.context, {
+            key: activeCartId,
+            region_id: (await this.medusaApi.getActiveRegion()).id,
+          }));
         } catch {
           // Cart doesn't exist, create new one
         }
@@ -360,7 +371,7 @@ export class MedusaCartProvider extends CartProvider {
   })
   public override async applyCouponCode(
     payload: CartMutationApplyCoupon
-  ): Promise<Result<Cart>> {
+  ): Promise<Result<CartFactoryCartOutput<TFactory>>> {
     try {
       const client = await this.getClient();
       const medusaId = payload.cart as MedusaCartIdentifier;
@@ -414,7 +425,7 @@ export class MedusaCartProvider extends CartProvider {
   })
   public override async removeCouponCode(
     payload: CartMutationRemoveCoupon
-  ): Promise<Result<Cart>> {
+  ): Promise<Result<CartFactoryCartOutput<TFactory>>> {
     try {
       const client = await this.getClient();
       const medusaId = payload.cart as MedusaCartIdentifier;
@@ -468,7 +479,7 @@ export class MedusaCartProvider extends CartProvider {
   })
   public override async changeCurrency(
     payload: CartMutationChangeCurrency
-  ): Promise<Result<Cart>> {
+  ): Promise<Result<CartFactoryCartOutput<TFactory>>> {
     try {
       const client = await this.getClient();
 
@@ -512,7 +523,9 @@ export class MedusaCartProvider extends CartProvider {
   }
 
 
-  protected async createCart(currency?: string): Promise<CartIdentifier> {
+  protected async createCart(
+    currency?: string,
+  ): Promise<CartFactoryIdentifierOutput<TFactory>> {
     try {
       const client = await this.getClient();
 
@@ -524,7 +537,7 @@ export class MedusaCartProvider extends CartProvider {
       );
 
       if (response.cart) {
-        const cartIdentifier = MedusaCartIdentifierSchema.parse({
+        const cartIdentifier = this.factory.parseCartIdentifier(this.context, {
           key: response.cart.id,
           region_id: response.cart.region_id,
         });
@@ -601,7 +614,7 @@ export class MedusaCartProvider extends CartProvider {
    * @param remote
    * @returns
    */
-  protected parseSingle(remote: StoreCart): Cart {
+  protected parseSingle(remote: StoreCart): CartFactoryCartOutput<TFactory> {
     const identifier = MedusaCartIdentifierSchema.parse({
       key: remote.id,
       region_id: remote.region_id,
@@ -659,6 +672,6 @@ export class MedusaCartProvider extends CartProvider {
       },
     } satisfies Cart;
 
-    return result;
+    return this.factory.parseCart(this.context, result);
   }
 }

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

@@ -2,7 +2,15 @@ import type {
   StoreProductCategory,
   StoreProductCategoryListResponse,
 } from '@medusajs/types';
-import type { Category, Cache, CategoryPaginatedResult } from '@reactionary/core';
+import type {
+  Category,
+  Cache,
+  CategoryFactory,
+  CategoryFactoryCategoryOutput,
+  CategoryFactoryPaginatedOutput,
+  CategoryFactoryWithOutput,
+  CategoryPaginatedResult,
+} from '@reactionary/core';
 import {
   CategoryIdentifierSchema,
   CategoryProvider,
@@ -28,18 +36,27 @@ import {
 } from '@reactionary/core';
 import type { MedusaAPI, MedusaConfiguration } from '../index.js';
 import * as z from 'zod';
+import type { MedusaCategoryFactory } from '../factories/category/category.factory.js';
 
-export class MedusaCategoryProvider extends CategoryProvider {
+export class MedusaCategoryProvider<
+  TFactory extends CategoryFactory = MedusaCategoryFactory,
+> extends CategoryProvider<
+  CategoryFactoryCategoryOutput<TFactory>,
+  CategoryFactoryPaginatedOutput<TFactory>
+> {
   protected config: MedusaConfiguration;
+  protected factory: CategoryFactoryWithOutput<TFactory>;
 
   constructor(
     config: MedusaConfiguration,
     cache: Cache,
     context: RequestContext,
-    public medusaApi: MedusaAPI
+    public medusaApi: MedusaAPI,
+    factory: CategoryFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
     this.config = config;
+    this.factory = factory;
   }
 
   protected async resolveCategoryIdByExternalId(
@@ -82,7 +99,9 @@ export class MedusaCategoryProvider extends CategoryProvider {
     inputSchema: CategoryQueryByIdSchema,
     outputSchema: CategorySchema,
   })
-  public override async getById(payload: CategoryQueryById): Promise<Result<Category, NotFoundError>> {
+  public override async getById(
+    payload: CategoryQueryById,
+  ): Promise<Result<CategoryFactoryCategoryOutput<TFactory>, NotFoundError>> {
     const candidate = await this.resolveCategoryIdByExternalId(payload.id.key);
     if (!candidate) {
       return error<NotFoundError>({
@@ -107,7 +126,7 @@ export class MedusaCategoryProvider extends CategoryProvider {
   })
   public override async getBySlug(
     payload: CategoryQueryBySlug
-  ): Promise<Result<Category, NotFoundError>> {
+  ): Promise<Result<CategoryFactoryCategoryOutput<TFactory>, NotFoundError>> {
     const sdk = await this.medusaApi.getClient();
 
     const categoryResult = await sdk.store.category.list(this.getBySlugPayload(payload));
@@ -126,7 +145,7 @@ export class MedusaCategoryProvider extends CategoryProvider {
   })
   public override async getBreadcrumbPathToCategory(
     payload: CategoryQueryForBreadcrumb
-  ): Promise<Result<Category[]>> {
+  ): Promise<Result<CategoryFactoryCategoryOutput<TFactory>[]>> {
     const actualCategoryId = await this.resolveCategoryIdByExternalId(
       payload.id.key
     );
@@ -140,7 +159,7 @@ export class MedusaCategoryProvider extends CategoryProvider {
       include_ancestors_tree: true,
     });
 
-    let results = new Array<Category>();
+    let results = new Array<CategoryFactoryCategoryOutput<TFactory>>();
     let current: StoreProductCategory | null = path.product_category;
     while (current) {
       results.push(this.parseSingle(current));
@@ -209,7 +228,7 @@ export class MedusaCategoryProvider extends CategoryProvider {
     return success(result);
   }
 
-  protected parseSingle(_body: StoreProductCategory): Category {
+  protected parseSingle(_body: StoreProductCategory): CategoryFactoryCategoryOutput<TFactory> {
     const identifier = CategoryIdentifierSchema.parse({
       key: _body.metadata?.['external_id'] || '',
     });
@@ -230,12 +249,12 @@ export class MedusaCategoryProvider extends CategoryProvider {
       images: [],
     } satisfies Category;
 
-    return result;
+    return this.factory.parseCategory(this.context, result);
   }
 
   protected parsePaginatedResult(
     body: StoreProductCategoryListResponse
-  ) {
+  ): CategoryFactoryPaginatedOutput<TFactory> {
     const items = body.product_categories.map((x) => this.parseSingle(x));
 
     const totalPages = Math.ceil(
@@ -254,7 +273,6 @@ export class MedusaCategoryProvider extends CategoryProvider {
       items: items,
     } satisfies CategoryPaginatedResult;
 
-    return result;
+    return this.factory.parseCategoryPaginatedResult(this.context, result);
   }
 }
-