@reactionary/source 0.6.1 → 0.6.3

package/packages/commercetools/src/factories/inventory/inventory.factory.ts

@@ -0,0 +1,49 @@
+import type { InventoryEntry } from '@commercetools/platform-sdk';
+import type {
+  InventorySchema} from '@reactionary/core';
+import {
+  type AnyInventorySchema,
+  type Inventory,
+  type InventoryFactory,
+  type InventoryIdentifier,
+  type InventoryStatus,
+  type RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class CommercetoolsInventoryFactory<
+  TInventorySchema extends AnyInventorySchema = typeof InventorySchema,
+> implements InventoryFactory<TInventorySchema>
+{
+  public readonly inventorySchema: TInventorySchema;
+
+  constructor(inventorySchema: TInventorySchema) {
+    this.inventorySchema = inventorySchema;
+  }
+
+  public parseInventory(
+    _context: RequestContext,
+    data: InventoryEntry,
+  ): z.output<TInventorySchema> {
+    const identifier = {
+      variant: { sku: data.sku || '' },
+      fulfillmentCenter: {
+        key: data.supplyChannel?.obj?.key || '',
+      },
+    } satisfies InventoryIdentifier;
+
+    const quantity = data.availableQuantity || 0;
+    let status: InventoryStatus = 'outOfStock';
+    if (quantity > 0) {
+      status = 'inStock';
+    }
+
+    const result = {
+      identifier,
+      quantity,
+      status,
+    } satisfies Inventory;
+
+    return this.inventorySchema.parse(result);
+  }
+}

package/packages/commercetools/src/factories/order/order.factory.ts

@@ -0,0 +1,149 @@
+import type { Order as CTOrder } from '@commercetools/platform-sdk';
+import type {
+  OrderSchema} from '@reactionary/core';
+import {
+  type AnyOrderSchema,
+  type CostBreakDown,
+  type Currency,
+  type ItemCostBreakdown,
+  type Order,
+  type OrderFactory,
+  type OrderIdentifier,
+  type OrderItem,
+  type OrderStatus,
+  type ProductVariantIdentifier,
+  type RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+import type { CommercetoolsOrderIdentifier } from '../../schema/commercetools.schema.js';
+
+export class CommercetoolsOrderFactory<
+  TOrderSchema extends AnyOrderSchema = typeof OrderSchema,
+> implements OrderFactory<TOrderSchema>
+{
+  public readonly orderSchema: TOrderSchema;
+
+  constructor(orderSchema: TOrderSchema) {
+    this.orderSchema = orderSchema;
+  }
+
+  public parseOrder(
+    _context: RequestContext,
+    data: CTOrder,
+  ): z.output<TOrderSchema> {
+    const identifier = {
+      key: data.id,
+      version: data.version || 0,
+    } satisfies CommercetoolsOrderIdentifier;
+
+    const name = data.custom?.fields['name'] || '';
+    const description = data.custom?.fields['description'] || '';
+
+    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: data.shippingInfo?.price.currencyCode as Currency,
+      },
+      totalProductPrice: {
+        value: productTotal / 100,
+        currency,
+      },
+      grandTotal: {
+        value: grandTotal / 100,
+        currency,
+      },
+    } satisfies CostBreakDown;
+
+    let orderStatus: OrderStatus = 'AwaitingPayment';
+    if (data.paymentState === 'Paid' && data.orderState === 'Confirmed') {
+      orderStatus = 'ReleasedToFulfillment';
+    }
+    if (data.shipmentState === 'Ready' && data.orderState === 'Confirmed') {
+      orderStatus = 'ReleasedToFulfillment';
+    }
+    if (
+      (data.shipmentState === 'Shipped' || data.shipmentState === 'Delivered') &&
+      data.orderState === 'Completed'
+    ) {
+      orderStatus = 'Shipped';
+    }
+
+    const items: OrderItem[] = [];
+    for (const remoteItem of data.lineItems) {
+      const lineIdentifier = {
+        key: remoteItem.id,
+      } satisfies OrderIdentifier;
+      const variant = {
+        sku: remoteItem.variant.sku || '',
+      } satisfies ProductVariantIdentifier;
+
+      const unitPrice = remoteItem.price.value.centAmount;
+      const totalPrice = remoteItem.totalPrice.centAmount || 0;
+      const totalDiscount = remoteItem.price.discounted?.value.centAmount || 0;
+      const unitDiscount = totalDiscount / remoteItem.quantity;
+
+      const linePrice = {
+        unitPrice: {
+          value: unitPrice / 100,
+          currency,
+        },
+        unitDiscount: {
+          value: unitDiscount / 100,
+          currency,
+        },
+        totalPrice: {
+          value: totalPrice / 100,
+          currency,
+        },
+        totalDiscount: {
+          value: totalDiscount / 100,
+          currency,
+        },
+      } satisfies ItemCostBreakdown;
+
+      items.push({
+        identifier: lineIdentifier,
+        inventoryStatus: 'NotAllocated',
+        price: linePrice,
+        quantity: remoteItem.quantity,
+        variant,
+      } satisfies OrderItem);
+    }
+
+    const result = {
+      identifier,
+      name,
+      description,
+      price,
+      items,
+      inventoryStatus: 'NotAllocated',
+      paymentInstructions: [],
+      userId: {
+        userId: '',
+      },
+      orderStatus,
+    } satisfies Order;
+
+    return this.orderSchema.parse(result);
+  }
+}

package/packages/commercetools/src/factories/order-search/order-search.factory.ts

@@ -0,0 +1,108 @@
+import type {
+  Address as CTAddress,
+  Order as CTOrder,
+  OrderPagedQueryResponse,
+} from '@commercetools/platform-sdk';
+import type {
+  OrderSearchResultSchema} from '@reactionary/core';
+import {
+  type Address,
+  type AnyOrderSearchResultSchema,
+  type Currency,
+  type IdentityIdentifier,
+  type MonetaryAmount,
+  type OrderSearchFactory,
+  type OrderSearchQueryByTerm,
+  type OrderSearchResult,
+  type OrderSearchResultItem,
+  type OrderStatus,
+  type RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class CommercetoolsOrderSearchFactory<
+  TOrderSearchResultSchema extends AnyOrderSearchResultSchema = typeof OrderSearchResultSchema,
+> implements OrderSearchFactory<TOrderSearchResultSchema>
+{
+  public readonly orderSearchResultSchema: TOrderSearchResultSchema;
+
+  constructor(orderSearchResultSchema: TOrderSearchResultSchema) {
+    this.orderSearchResultSchema = orderSearchResultSchema;
+  }
+
+  public parseOrderSearchResult(
+    context: RequestContext,
+    data: OrderPagedQueryResponse,
+    query: OrderSearchQueryByTerm,
+  ): z.output<TOrderSearchResultSchema> {
+    const result = {
+      identifier: {
+        ...query.search,
+      },
+      pageNumber: (Math.ceil(data.offset / data.limit) || 0) + 1,
+      pageSize: data.limit,
+      totalCount: data.total || 0,
+      totalPages: Math.ceil((data.total || 0) / data.limit || 0) + 1,
+      items: data.results.map((order) => this.parseOrderSearchItem(context, order)),
+    } satisfies OrderSearchResult;
+
+    return this.orderSearchResultSchema.parse(result);
+  }
+
+  protected parseAddress(data: CTAddress): Address {
+    return {
+      countryCode: data.country || '',
+      firstName: data.firstName || '',
+      lastName: data.lastName || '',
+      streetAddress: data.streetName || '',
+      streetNumber: data.streetNumber || '',
+      postalCode: data.postalCode || '',
+      city: data.city || '',
+      identifier: {
+        nickName: '',
+      },
+      region: '',
+    } satisfies Address;
+  }
+
+  protected parseOrderSearchItem(
+    context: RequestContext,
+    data: CTOrder,
+  ): OrderSearchResultItem {
+    const userId: IdentityIdentifier = {
+      userId: data.customerId || data.anonymousId || '',
+    };
+
+    let orderStatus: OrderStatus = 'AwaitingPayment';
+    if (data.paymentState === 'Paid' && data.orderState === 'Confirmed') {
+      orderStatus = 'ReleasedToFulfillment';
+    }
+    if (data.shipmentState === 'Ready' && data.orderState === 'Confirmed') {
+      orderStatus = 'ReleasedToFulfillment';
+    }
+    if (
+      (data.shipmentState === 'Shipped' || data.shipmentState === 'Delivered') &&
+      data.orderState === 'Completed'
+    ) {
+      orderStatus = 'Shipped';
+    }
+
+    const totalAmount: MonetaryAmount = {
+      currency: data.totalPrice
+        ? (data.totalPrice.currencyCode as Currency)
+        : context.languageContext.currencyCode,
+      value: data.totalPrice ? data.totalPrice.centAmount / 100 : 0,
+    };
+
+    return {
+      identifier: { key: data.id },
+      userId,
+      customerName: `${data.billingAddress?.firstName} ${data.billingAddress?.lastName}`,
+      shippingAddress: this.parseAddress(data.shippingAddress!),
+      orderDate: data.createdAt,
+      orderStatus,
+      inventoryStatus: orderStatus === 'Shipped' ? 'Allocated' : 'NotAllocated',
+      totalAmount,
+    } satisfies OrderSearchResultItem;
+  }
+}

package/packages/commercetools/src/factories/price/price.factory.ts

@@ -0,0 +1,76 @@
+import type { Price as CTPrice, ProductVariant as CTProductVariant } from '@commercetools/platform-sdk';
+import type {
+  PriceSchema} from '@reactionary/core';
+import {
+  type AnyPriceSchema,
+  type Currency,
+  type MonetaryAmount,
+  type Price,
+  type PriceFactory,
+  type PriceIdentifier,
+  type RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class CommercetoolsPriceFactory<
+  TPriceSchema extends AnyPriceSchema = typeof PriceSchema,
+> implements PriceFactory<TPriceSchema>
+{
+  public readonly priceSchema: TPriceSchema;
+
+  constructor(priceSchema: TPriceSchema) {
+    this.priceSchema = priceSchema;
+  }
+
+  public parsePrice(
+    context: RequestContext,
+    data: CTProductVariant,
+    options = { includeDiscounts: false },
+  ): z.output<TPriceSchema> {
+    const price = data.price as CTPrice | undefined;
+
+    if (!price) {
+      return this.priceSchema.parse({
+        identifier: {
+          variant: {
+            sku: data.sku || '',
+          },
+        },
+        onSale: false,
+        tieredPrices: [],
+        unitPrice: {
+          value: -1,
+          currency: context.languageContext.currencyCode,
+        },
+      } satisfies Price);
+    }
+
+    let unitPrice = {
+      value: price.value.centAmount / 100,
+      currency: price.value.currencyCode as Currency,
+    } satisfies MonetaryAmount;
+
+    if (options.includeDiscounts) {
+      const discountedPrice = price.discounted?.value || price.value;
+      unitPrice = {
+        value: discountedPrice.centAmount / 100,
+        currency: price.value.currencyCode as Currency,
+      } satisfies MonetaryAmount;
+    }
+
+    const identifier = {
+      variant: {
+        sku: data.sku || '',
+      },
+    } satisfies PriceIdentifier;
+
+    const result = {
+      identifier,
+      onSale: options.includeDiscounts && !!price.discounted,
+      tieredPrices: [],
+      unitPrice,
+    } satisfies Price;
+
+    return this.priceSchema.parse(result);
+  }
+}

package/packages/commercetools/src/factories/product/product-capability-custom-method-only.example.ts

@@ -0,0 +1,47 @@
+import { ProductSchema } from "@reactionary/core";
+import type { ProductFactoryOutput, Result } from "@reactionary/core";
+import { CommercetoolsProductFactory } from "./product.factory.js";
+import { CommercetoolsProductCapability } from "../../capabilities/product.capability.js";
+import { withCommercetoolsCapabilities } from "../../core/initialize.js";
+import { assertNotAny, assertType } from "./utils.example.js";
+
+const cache = {} as any;
+const context = {} as any;
+const config = {} as any;
+const api = {} as any;
+
+class ExtendedCommercetoolsProductCapability extends CommercetoolsProductCapability<CommercetoolsProductFactory> {
+  public async getByCustomIdentifier(
+    identifier: string
+  ): Promise<Result<ProductFactoryOutput<CommercetoolsProductFactory>>> {
+    return this.getById({
+      identifier: { key: identifier },
+    });
+  }
+}
+
+const withExtendedCapabilityFactory = withCommercetoolsCapabilities(config, {
+  product: {
+    enabled: true,
+    factory: new CommercetoolsProductFactory(ProductSchema),
+    capability: ({ cache, context, config, commercetoolsApi }) =>
+      new ExtendedCommercetoolsProductCapability(
+        cache,
+        context,
+        config,
+        commercetoolsApi,
+        new CommercetoolsProductFactory(ProductSchema)
+      ),
+  },
+});
+
+const client = withExtendedCapabilityFactory(cache, context);
+
+client.product.getByCustomIdentifier("p-2").then((x) => {
+  assertNotAny(x);
+  if (x.success) {
+    assertNotAny(x.value);
+    assertNotAny(x.value.name);
+    assertType<string>(x.value.name);
+  }
+});

package/packages/commercetools/src/factories/product/product-capability-schema-signature-extension.example.ts

@@ -0,0 +1,61 @@
+import { ProductQueryByIdSchema, ProductSchema } from "@reactionary/core";
+import type {
+  ProductFactoryOutput,
+  ProductQueryById as BaseProductQueryById,
+  Result,
+} from "@reactionary/core";
+import { CommercetoolsProductFactory } from "./product.factory.js";
+import { CommercetoolsProductCapability } from "../../capabilities/product.capability.js";
+import * as z from "zod";
+import { assertNotAny, assertType } from "./utils.example.js";
+
+const cache = {} as any;
+const context = {} as any;
+const config = {} as any;
+const api = {} as any;
+
+const ExtendedProductSchema = ProductSchema.safeExtend({
+  extendedValue: z.string(),
+});
+
+class ExtendedCommercetoolsProductFactory extends CommercetoolsProductFactory<typeof ExtendedProductSchema> {
+  constructor() {
+    super(ExtendedProductSchema);
+  }
+}
+
+const ExtendedProductQueryByIdSchema = ProductQueryByIdSchema.extend({
+  auditTrail: z.boolean(),
+});
+type ExtendedProductQueryById = z.infer<typeof ExtendedProductQueryByIdSchema>;
+
+class ExtendedCommercetoolsProductCapability extends CommercetoolsProductCapability<ExtendedCommercetoolsProductFactory> {
+  public override async getById(
+    payload: ExtendedProductQueryById
+  ) {
+    const basePayload: BaseProductQueryById = {
+      identifier: payload.identifier,
+    };
+    return super.getById(basePayload);
+  }
+}
+
+const extendedCapability = new ExtendedCommercetoolsProductCapability(
+  cache,
+  context,
+  config,
+  api,
+  new ExtendedCommercetoolsProductFactory()
+);
+
+extendedCapability.getById({
+  identifier: { key: "p-1" },
+  auditTrail: true
+}).then((x) => {
+  assertNotAny(x);
+  if (x.success) {
+    assertNotAny(x.value);
+    assertNotAny(x.value.extendedValue);
+    assertType<string>(x.value.extendedValue);
+  }
+});

package/packages/commercetools/src/factories/product/product-factory-baseline.example.ts

@@ -0,0 +1,14 @@
+import { ProductSchema } from "@reactionary/core";
+import { CommercetoolsProductFactory } from "./product.factory.js";
+import { assertNotAny, assertType } from "./utils.example.js";
+
+const context = {} as any;
+
+const baseFactory = new CommercetoolsProductFactory(ProductSchema);
+const baseProduct = baseFactory.parseProduct(context, {} as any);
+
+assertNotAny(baseProduct);
+assertNotAny(baseProduct.name);
+assertType<string>(baseProduct.name);
+// @ts-expect-error base schema does not include extendedValue
+assertType<string>(baseProduct.extendedValue);

package/packages/commercetools/src/factories/product/product-factory-schema-and-parse-extension.example.ts

@@ -0,0 +1,35 @@
+import { ProductSchema } from "@reactionary/core";
+import type { RequestContext } from "@reactionary/core";
+import type { ProductProjection } from "@commercetools/platform-sdk";
+import { CommercetoolsProductFactory } from "./product.factory.js";
+import * as z from "zod";
+import { assertNotAny, assertType } from "./utils.example.js";
+
+const context = {} as any;
+
+const ExtendedProductSchema = ProductSchema.safeExtend({
+  extendedValue: z.string(),
+});
+
+class ExtendedCommercetoolsProductFactory extends CommercetoolsProductFactory<typeof ExtendedProductSchema> {
+  constructor() {
+    super(ExtendedProductSchema);
+  }
+
+  public override parseProduct(context: RequestContext, data: ProductProjection) {
+    const base = super.parseProduct(context, data);
+
+    // PAIN: Needing the satisfies here - possibly unavoidable
+    return {
+      ...base,
+      extendedValue: "from-parse",
+    } satisfies z.output<typeof ExtendedProductSchema>;
+  }
+}
+
+const extendedFactory = new ExtendedCommercetoolsProductFactory();
+const extendedProduct = extendedFactory.parseProduct(context, {} as any);
+
+assertNotAny(extendedProduct);
+assertNotAny(extendedProduct.extendedValue);
+assertType<string>(extendedProduct.extendedValue);

package/packages/commercetools/src/factories/product/product-factory-schema-extension.example.ts

@@ -0,0 +1,23 @@
+import { ProductSchema } from "@reactionary/core";
+import { CommercetoolsProductFactory } from "./product.factory.js";
+import * as z from "zod";
+import { assertNotAny, assertType } from "./utils.example.js";
+
+const context = {} as any;
+
+const ExtendedProductSchema = ProductSchema.safeExtend({
+  extendedValue: z.string(),
+});
+
+class ExtendedCommercetoolsProductFactory extends CommercetoolsProductFactory<typeof ExtendedProductSchema> {
+  constructor() {
+    super(ExtendedProductSchema);
+  }
+}
+
+const extendedFactory = new ExtendedCommercetoolsProductFactory();
+const extendedProduct = extendedFactory.parseProduct(context, {} as any);
+
+assertNotAny(extendedProduct);
+assertNotAny(extendedProduct.extendedValue);
+assertType<string>(extendedProduct.extendedValue);

package/packages/commercetools/src/factories/product/product-initializer-factory-extension.example.ts

@@ -0,0 +1,41 @@
+import { ProductSchema } from "@reactionary/core";
+import { CommercetoolsProductFactory } from "./product.factory.js";
+import { withCommercetoolsCapabilities } from "../../core/initialize.js";
+import * as z from "zod";
+import { assertNotAny, assertType } from "./utils.example.js";
+
+const cache = {} as any;
+const context = {} as any;
+const config = {} as any;
+
+const ExtendedProductSchema = ProductSchema.safeExtend({
+  extendedValue: z.string(),
+});
+
+class ExtendedCommercetoolsProductFactory extends CommercetoolsProductFactory<typeof ExtendedProductSchema> {
+  constructor() {
+    super(ExtendedProductSchema);
+  }
+}
+
+const capabilityFactory = withCommercetoolsCapabilities(config, {
+  product: {
+    enabled: true,
+    factory: new ExtendedCommercetoolsProductFactory(),
+  },
+});
+
+const client = capabilityFactory(cache, context);
+
+client.product
+  .getById({
+    identifier: { key: "p-1" },
+  })
+  .then((x) => {
+    assertNotAny(x);
+    if (x.success) {
+      assertNotAny(x.value);
+      assertNotAny(x.value.extendedValue);
+      assertType<string>(x.value.extendedValue);
+    }
+  });