@reactionary/source 0.3.18 → 0.6.2

package/providers/commercetools/src/core/initialize.types.ts

@@ -0,0 +1,174 @@
+import type {
+  CartFactory,
+  CategoryFactory,
+  CheckoutFactory,
+  ClientFromCapabilities,
+  IdentityFactory,
+  InventoryFactory,
+  OrderFactory,
+  OrderSearchFactory,
+  PriceFactory,
+  ProductAssociationsFactory,
+  ProductFactory,
+  ProductListFactory,
+  ProductReviewsFactory,
+  ProductSearchFactory,
+  ProfileFactory,
+  StoreFactory,
+} from '@reactionary/core';
+import type { CommercetoolsCapabilities } from '../schema/capabilities.schema.js';
+import type { OverridableCapabilityKey } from './capability-descriptors.js';
+import type { CommercetoolsCartFactory } from '../factories/cart/cart.factory.js';
+import type { CommercetoolsCategoryFactory } from '../factories/category/category.factory.js';
+import type { CommercetoolsCheckoutFactory } from '../factories/checkout/checkout.factory.js';
+import type { CommercetoolsIdentityFactory } from '../factories/identity/identity.factory.js';
+import type { CommercetoolsInventoryFactory } from '../factories/inventory/inventory.factory.js';
+import type { CommercetoolsOrderFactory } from '../factories/order/order.factory.js';
+import type { CommercetoolsOrderSearchFactory } from '../factories/order-search/order-search.factory.js';
+import type { CommercetoolsPriceFactory } from '../factories/price/price.factory.js';
+import type { CommercetoolsProductAssociationsFactory } from '../factories/product-associations/product-associations.factory.js';
+import type { CommercetoolsProductFactory } from '../factories/product/product.factory.js';
+import type { CommercetoolsProductListFactory } from '../factories/product-list/product-list.factory.js';
+import type { CommercetoolsProductReviewsFactory } from '../factories/product-reviews/product-reviews.factory.js';
+import type { CommercetoolsProductSearchFactory } from '../factories/product-search/product-search.factory.js';
+import type { CommercetoolsProfileFactory } from '../factories/profile/profile.factory.js';
+import type { CommercetoolsStoreFactory } from '../factories/store/store.factory.js';
+import type { CommercetoolsCartProvider } from '../providers/cart.provider.js';
+import type { CommercetoolsCategoryProvider } from '../providers/category.provider.js';
+import type { CommercetoolsCheckoutProvider } from '../providers/checkout.provider.js';
+import type { CommercetoolsIdentityProvider } from '../providers/identity.provider.js';
+import type { CommercetoolsInventoryProvider } from '../providers/inventory.provider.js';
+import type { CommercetoolsOrderSearchProvider } from '../providers/order-search.provider.js';
+import type { CommercetoolsOrderProvider } from '../providers/order.provider.js';
+import type { CommercetoolsPriceProvider } from '../providers/price.provider.js';
+import type { CommercetoolsProductAssociationsProvider } from '../providers/product-associations.provider.js';
+import type { CommercetoolsProductListProvider } from '../providers/product-list.provider.js';
+import type { CommercetoolsProductProvider } from '../providers/product.provider.js';
+import type { CommercetoolsProductReviewsProvider } from '../providers/product-reviews.provider.js';
+import type { CommercetoolsSearchProvider } from '../providers/product-search.provider.js';
+import type { CommercetoolsProfileProvider } from '../providers/profile.provider.js';
+import type { CommercetoolsStoreProvider } from '../providers/store.provider.js';
+
+type EnabledCapability<TCapability> =
+  TCapability extends { enabled: true } ? true : false;
+
+type NormalizeConfiguredCapabilities<T extends CommercetoolsCapabilities> =
+  Omit<T, OverridableCapabilityKey> & {
+    [K in OverridableCapabilityKey]?: EnabledCapability<T[K]>;
+  };
+
+type ExtractCapabilityFactory<TCapability, TContract, TDefaultFactory> =
+  TCapability extends { enabled: true; factory?: infer TFactory }
+    ? TFactory extends TContract
+      ? TFactory
+      : TDefaultFactory
+    : TDefaultFactory;
+
+type ExtractCapabilityProvider<TCapability, TDefaultProvider> =
+  TCapability extends { enabled: true; provider?: infer TProviderFactory }
+    ? TProviderFactory extends (...args: any[]) => infer TProvider
+      ? TProvider
+      : TDefaultProvider
+    : TDefaultProvider;
+
+type FactoryContractMap = {
+  product: ProductFactory;
+  productSearch: ProductSearchFactory;
+  productAssociations: ProductAssociationsFactory;
+  productReviews: ProductReviewsFactory;
+  productList: ProductListFactory;
+  identity: IdentityFactory;
+  cart: CartFactory;
+  checkout: CheckoutFactory;
+  order: OrderFactory;
+  orderSearch: OrderSearchFactory;
+  inventory: InventoryFactory;
+  price: PriceFactory;
+  category: CategoryFactory;
+  store: StoreFactory;
+  profile: ProfileFactory;
+};
+
+type DefaultFactoryMap = {
+  product: CommercetoolsProductFactory;
+  productSearch: CommercetoolsProductSearchFactory;
+  productAssociations: CommercetoolsProductAssociationsFactory;
+  productReviews: CommercetoolsProductReviewsFactory;
+  productList: CommercetoolsProductListFactory;
+  identity: CommercetoolsIdentityFactory;
+  cart: CommercetoolsCartFactory;
+  checkout: CommercetoolsCheckoutFactory;
+  order: CommercetoolsOrderFactory;
+  orderSearch: CommercetoolsOrderSearchFactory;
+  inventory: CommercetoolsInventoryFactory;
+  price: CommercetoolsPriceFactory;
+  category: CommercetoolsCategoryFactory;
+  store: CommercetoolsStoreFactory;
+  profile: CommercetoolsProfileFactory;
+};
+
+type ResolvedFactoryMap<T extends CommercetoolsCapabilities> = {
+  [K in OverridableCapabilityKey]: ExtractCapabilityFactory<
+    T[K],
+    FactoryContractMap[K],
+    DefaultFactoryMap[K]
+  >;
+};
+
+type DefaultProviderMap<T extends CommercetoolsCapabilities> = {
+  product: CommercetoolsProductProvider<ResolvedFactoryMap<T>['product']>;
+  productSearch: CommercetoolsSearchProvider<ResolvedFactoryMap<T>['productSearch']>;
+  productAssociations: CommercetoolsProductAssociationsProvider<
+    ResolvedFactoryMap<T>['productAssociations']
+  >;
+  productReviews: CommercetoolsProductReviewsProvider<
+    ResolvedFactoryMap<T>['productReviews']
+  >;
+  productList: CommercetoolsProductListProvider<ResolvedFactoryMap<T>['productList']>;
+  identity: CommercetoolsIdentityProvider<ResolvedFactoryMap<T>['identity']>;
+  cart: CommercetoolsCartProvider<ResolvedFactoryMap<T>['cart']>;
+  checkout: CommercetoolsCheckoutProvider<ResolvedFactoryMap<T>['checkout']>;
+  order: CommercetoolsOrderProvider<ResolvedFactoryMap<T>['order']>;
+  orderSearch: CommercetoolsOrderSearchProvider<ResolvedFactoryMap<T>['orderSearch']>;
+  inventory: CommercetoolsInventoryProvider<ResolvedFactoryMap<T>['inventory']>;
+  price: CommercetoolsPriceProvider<ResolvedFactoryMap<T>['price']>;
+  category: CommercetoolsCategoryProvider<ResolvedFactoryMap<T>['category']>;
+  store: CommercetoolsStoreProvider<ResolvedFactoryMap<T>['store']>;
+  profile: CommercetoolsProfileProvider<ResolvedFactoryMap<T>['profile']>;
+};
+
+type CapabilityProviderTypeMap<T extends CommercetoolsCapabilities> = {
+  [K in OverridableCapabilityKey]: ExtractCapabilityProvider<T[K], DefaultProviderMap<T>[K]>;
+};
+
+type EnabledCapabilityOverrideMap<T extends CommercetoolsCapabilities> = {
+  [K in OverridableCapabilityKey as T[K] extends { enabled: true } ? K : never]:
+    CapabilityProviderTypeMap<T>[K];
+};
+
+export type CommercetoolsClientFromCapabilities<
+  T extends CommercetoolsCapabilities,
+> = Omit<
+  ClientFromCapabilities<NormalizeConfiguredCapabilities<T>>,
+  OverridableCapabilityKey
+> &
+  EnabledCapabilityOverrideMap<T>;
+
+export function resolveCapabilityProvider<TFactory, TProvider, TProviderArgs>(
+  capability:
+    | {
+        factory?: TFactory;
+        provider?: (args: TProviderArgs) => TProvider;
+      }
+    | undefined,
+  defaults: {
+    factory: TFactory;
+    provider: (args: TProviderArgs) => TProvider;
+  },
+  buildProviderArgs: (factory: TFactory) => TProviderArgs,
+): TProvider {
+  const factory = capability?.factory ?? defaults.factory;
+  const provider = capability?.provider ?? defaults.provider;
+
+  return provider(buildProviderArgs(factory));
+}

package/providers/commercetools/src/factories/cart/cart.factory.ts

@@ -0,0 +1,142 @@
+import type { Cart as CTCart, LineItem } from '@commercetools/platform-sdk';
+import type {
+  CartIdentifierSchema,
+  CartSchema} from '@reactionary/core';
+import {
+  CartItemSchema,
+  type AnyCartIdentifierSchema,
+  type AnyCartSchema,
+  type Cart,
+  type CartFactory,
+  type CartIdentifier,
+  type CartItem,
+  type CostBreakDown,
+  type Currency,
+  type RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class CommercetoolsCartFactory<
+  TCartSchema extends AnyCartSchema = typeof CartSchema,
+  TCartIdentifierSchema extends AnyCartIdentifierSchema = typeof CartIdentifierSchema,
+> implements CartFactory<TCartSchema, TCartIdentifierSchema>
+{
+  public readonly cartSchema: TCartSchema;
+  public readonly cartIdentifierSchema: TCartIdentifierSchema;
+
+  constructor(cartSchema: TCartSchema, cartIdentifierSchema: TCartIdentifierSchema) {
+    this.cartSchema = cartSchema;
+    this.cartIdentifierSchema = cartIdentifierSchema;
+  }
+
+  public parseCartIdentifier(
+    _context: RequestContext,
+    data: { key?: string },
+  ): z.output<TCartIdentifierSchema> {
+    return this.cartIdentifierSchema.parse({
+      key: data.key || '',
+    } satisfies Partial<CartIdentifier>);
+  }
+
+  public parseCart(
+    context: RequestContext,
+    data: CTCart,
+  ): z.output<TCartSchema> {
+    const identifier = this.parseCartIdentifier(context, {
+      key: data.id,
+    });
+
+    const grandTotal = data.totalPrice.centAmount || 0;
+    const shippingTotal = data.shippingInfo?.price.centAmount || 0;
+    const productTotal = grandTotal - shippingTotal;
+    const taxTotal = data.taxedPrice?.totalTax?.centAmount || 0;
+    const discountTotal = data.discountOnTotalPrice?.discountedAmount.centAmount || 0;
+    const surchargeTotal = 0;
+    const currency = data.totalPrice.currencyCode as Currency;
+
+    const price = {
+      totalTax: {
+        value: taxTotal / 100,
+        currency,
+      },
+      totalDiscount: {
+        value: discountTotal / 100,
+        currency,
+      },
+      totalSurcharge: {
+        value: surchargeTotal / 100,
+        currency,
+      },
+      totalShipping: {
+        value: shippingTotal / 100,
+        currency,
+      },
+      totalProductPrice: {
+        value: productTotal / 100,
+        currency,
+      },
+      grandTotal: {
+        value: grandTotal / 100,
+        currency,
+      },
+    } satisfies CostBreakDown;
+
+    const items: CartItem[] = [];
+    for (const lineItem of data.lineItems) {
+      items.push(this.parseCartItem(lineItem));
+    }
+
+    const result = {
+      identifier,
+      userId: {
+        userId: '???',
+      },
+      name: data.custom?.fields['name'] || '',
+      description: data.custom?.fields['description'] || '',
+      price,
+      items,
+      appliedPromotions: [],
+    } satisfies Cart;
+
+    return this.cartSchema.parse(result);
+  }
+
+  protected parseCartItem(lineItem: LineItem): CartItem {
+    const unitPrice = lineItem.price.value.centAmount;
+    const totalPrice = lineItem.totalPrice.centAmount || 0;
+    const totalDiscount = lineItem.price.discounted?.value.centAmount || 0;
+    const unitDiscount = totalDiscount / lineItem.quantity;
+    const currency = lineItem.price.value.currencyCode.toUpperCase() as Currency;
+
+    return CartItemSchema.parse({
+      identifier: {
+        key: lineItem.id,
+      },
+      product: {
+        key: lineItem.productId,
+      },
+      variant: {
+        sku: lineItem.variant.sku || '',
+      },
+      quantity: lineItem.quantity,
+      price: {
+        unitPrice: {
+          value: unitPrice / 100,
+          currency,
+        },
+        unitDiscount: {
+          value: unitDiscount / 100,
+          currency,
+        },
+        totalPrice: {
+          value: totalPrice / 100,
+          currency,
+        },
+        totalDiscount: {
+          value: totalDiscount / 100,
+          currency,
+        },
+      },
+    } satisfies Partial<CartItem>);
+  }
+}

package/providers/commercetools/src/factories/category/category.factory.ts

@@ -0,0 +1,77 @@
+import type { Category as CTCategory, CategoryPagedQueryResponse } from '@commercetools/platform-sdk';
+import type {
+  CategoryPaginatedResultSchema,
+  CategorySchema} from '@reactionary/core';
+import {
+  type AnyCategoryPaginatedResultSchema,
+  type AnyCategorySchema,
+  type Category,
+  type CategoryFactory,
+  type CategoryIdentifier,
+  type CategoryPaginatedResult,
+  type RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class CommercetoolsCategoryFactory<
+  TCategorySchema extends AnyCategorySchema = typeof CategorySchema,
+  TCategoryPaginatedSchema extends AnyCategoryPaginatedResultSchema = typeof CategoryPaginatedResultSchema,
+> implements CategoryFactory<TCategorySchema, TCategoryPaginatedSchema>
+{
+  public readonly categorySchema: TCategorySchema;
+  public readonly categoryPaginatedResultSchema: TCategoryPaginatedSchema;
+
+  constructor(
+    categorySchema: TCategorySchema,
+    categoryPaginatedResultSchema: TCategoryPaginatedSchema,
+  ) {
+    this.categorySchema = categorySchema;
+    this.categoryPaginatedResultSchema = categoryPaginatedResultSchema;
+  }
+
+  public parseCategory(
+    context: RequestContext,
+    data: CTCategory,
+  ): z.output<TCategorySchema> {
+    const identifier = { key: data.key || '' } satisfies CategoryIdentifier;
+    const result = {
+      identifier,
+      name: data.name[context.languageContext.locale] || 'No Name',
+      slug: data.slug ? data.slug[context.languageContext.locale] || '' : '',
+      text: data.description ? data.description[context.languageContext.locale] || '' : '',
+      parentCategory:
+        data.parent && data.parent.obj && data.parent.obj?.key
+          ? { key: data.parent.obj.key }
+          : undefined,
+      images: (data.assets || [])
+        .filter((asset) => asset.sources.length > 0)
+        .filter((asset) => asset.sources[0].contentType?.startsWith('image/'))
+        .map((asset) => ({
+          sourceUrl: asset.sources[0].uri,
+          altText:
+            asset.description?.[context.languageContext.locale] ||
+            asset.name[context.languageContext.locale] ||
+            '',
+          height: asset.sources[0].dimensions?.h || 0,
+          width: asset.sources[0].dimensions?.w || 0,
+        })),
+    } satisfies Category;
+
+    return this.categorySchema.parse(result);
+  }
+
+  public parseCategoryPaginatedResult(
+    context: RequestContext,
+    data: CategoryPagedQueryResponse,
+  ): z.output<TCategoryPaginatedSchema> {
+    const result = {
+      pageNumber: Math.floor(data.offset / data.count) + 1,
+      pageSize: data.count,
+      totalCount: data.total || 0,
+      totalPages: Math.ceil((data.total ?? 0) / data.count),
+      items: data.results.map((category) => this.parseCategory(context, category)),
+    } satisfies CategoryPaginatedResult;
+
+    return this.categoryPaginatedResultSchema.parse(result);
+  }
+}

package/providers/commercetools/src/factories/checkout/checkout-initializer-overrides.example.ts

@@ -0,0 +1,94 @@
+import type { Cart as CTCart } from "@commercetools/platform-sdk";
+import {
+  CheckoutSchema,
+  PaymentMethodSchema,
+  ShippingMethodSchema,
+  type CheckoutQueryById,
+  type RequestContext,
+  unwrapValue,
+} from "@reactionary/core";
+import { withCommercetoolsCapabilities } from "../../core/initialize.js";
+import { CommercetoolsCheckoutProvider } from "../../providers/checkout.provider.js";
+import { assertNotAny, assertType } from "../product/utils.example.js";
+import { CommercetoolsCheckoutFactory } from "./checkout.factory.js";
+import * as z from "zod";
+
+const cache = {} as any;
+const context = {} as any;
+const config = {} as any;
+
+const ExtendedCheckoutSchema = CheckoutSchema.safeExtend({
+  extendedValue: z.string().default(""),
+});
+
+type ExtendedCheckout = z.output<typeof ExtendedCheckoutSchema>;
+
+class ExtendedCommercetoolsCheckoutFactory extends CommercetoolsCheckoutFactory<
+  typeof ExtendedCheckoutSchema,
+  typeof ShippingMethodSchema,
+  typeof PaymentMethodSchema
+> {
+  constructor() {
+    super(ExtendedCheckoutSchema, ShippingMethodSchema, PaymentMethodSchema);
+  }
+
+  public override parseCheckout(
+    context: RequestContext,
+    data: CTCart,
+  ): ExtendedCheckout {
+    const base = super.parseCheckout(context, data);
+    return {
+      ...base,
+      extendedValue: "from-factory",
+    };
+  }
+}
+
+class ExtendedCommercetoolsCheckoutProvider extends CommercetoolsCheckoutProvider<ExtendedCommercetoolsCheckoutFactory> {
+  public async getByIdOrThrow(payload: CheckoutQueryById): Promise<ExtendedCheckout> {
+    const result = await this.getById(payload);
+    return unwrapValue(result);
+  }
+}
+
+const extendedFactory = new ExtendedCommercetoolsCheckoutFactory();
+
+const capabilityFactory = withCommercetoolsCapabilities(config, {
+  checkout: {
+    enabled: true,
+    factory: extendedFactory,
+    provider: ({ cache, context, config, commercetoolsApi }) =>
+      new ExtendedCommercetoolsCheckoutProvider(
+        config,
+        cache,
+        context,
+        commercetoolsApi,
+        extendedFactory,
+      ),
+  },
+});
+
+const client = capabilityFactory(cache, context);
+
+client.checkout
+  .getById({
+    identifier: { key: "checkout-1" },
+  })
+  .then((result) => {
+    assertNotAny(result);
+    if (result.success) {
+      assertNotAny(result.value);
+      assertNotAny(result.value.extendedValue);
+      assertType<string>(result.value.extendedValue);
+    }
+  });
+
+client.checkout
+  .getByIdOrThrow({
+    identifier: { key: "checkout-2" },
+  })
+  .then((checkout) => {
+    assertNotAny(checkout);
+    assertNotAny(checkout.extendedValue);
+    assertType<string>(checkout.extendedValue);
+  });