@jarwizz/create-jarshop 0.1.4 → 0.1.6

package/dist/template/src/plugins/jarshop-checkout/order-email-lifecycle.ts

@@ -0,0 +1,355 @@
+import { HistoryEntryType } from "@vendure/common/lib/generated-types";
+import {
+  Inject,
+  Injectable,
+  Logger,
+  OnApplicationBootstrap,
+  OnModuleDestroy,
+} from "@nestjs/common";
+import {
+  EventBus,
+  FulfillmentStateTransitionEvent,
+  HistoryEntryEvent,
+  isGraphQlErrorResult,
+  Order,
+  OrderService,
+  OrderStateTransitionEvent,
+  TransactionalConnection,
+  type OrderLine,
+  type RequestContext,
+} from "@vendure/core";
+import { JarShopOrderEmailDelivery } from "./order-email-delivery.entity.js";
+import { JarShopEmailBrandConfiguration } from "./order-email-configuration.entity.js";
+import { isLifecycleEmailEnabled } from "./order-email-configuration.js";
+import {
+  createPendingCancellationEmailDelivery,
+  createPendingFulfillmentEmailDelivery,
+  decryptOrderEmailOutboxPayload,
+  isSnapshotOrderEmailOutboxPayload,
+  type OrderEmailLineSnapshot,
+} from "./order-email-outbox.js";
+import { toOrderEmailLanguageCode } from "./order-email-delivery-core.js";
+import {
+  getCourierOrderAlignmentState,
+  resolveLocalizedVariantName,
+  resolveShippingMethodCodeForOrderLines,
+  toFulfillmentLifecycleEmailKind,
+} from "./order-lifecycle-core.js";
+
+type CancellationHistoryInput = {
+  type: HistoryEntryType.ORDER_CANCELLATION;
+  data: {
+    lines: ReadonlyArray<{ orderLineId: string | number; quantity: number }>;
+    shippingCancelled: boolean;
+  };
+};
+
+export const fulfillmentLifecycleOrderRelations = [
+  "customer",
+  "lines.productVariant",
+  "lines.productVariant.translations",
+  "shippingLines.shippingMethod",
+  "shippingLines.orderLines",
+  "fulfillments.lines",
+] as const;
+
+@Injectable()
+export class JarShopOrderEmailLifecycleOutbox
+  implements OnApplicationBootstrap, OnModuleDestroy
+{
+  private orderStateSubscription: { unsubscribe(): void } | undefined;
+
+  constructor(
+    @Inject(TransactionalConnection)
+    private readonly connection: TransactionalConnection,
+    @Inject(EventBus)
+    private readonly eventBus: EventBus,
+    @Inject(OrderService)
+    private readonly orderService: OrderService,
+  ) {}
+
+  onApplicationBootstrap(): void {
+    this.eventBus.registerBlockingEventHandler({
+      event: FulfillmentStateTransitionEvent,
+      id: "jarshop-order-email-fulfillment-transition",
+      handler: (event) => this.enqueueFulfillmentTransition(event),
+    });
+    this.eventBus.registerBlockingEventHandler({
+      event: HistoryEntryEvent,
+      id: "jarshop-order-email-order-cancellation",
+      handler: (event) => this.enqueueCancellation(event),
+    });
+    this.orderStateSubscription = this.eventBus
+      .ofType(OrderStateTransitionEvent)
+      .subscribe((event) => {
+        if (event.toState !== "PaymentSettled") return;
+        void this.alignSettledCourierOrder(event).catch(() => {
+          Logger.error(
+            "Settled courier order could not be aligned with its fulfillments",
+            "JarShopOrderEmailLifecycleOutbox",
+          );
+        });
+      });
+  }
+
+  onModuleDestroy(): void {
+    this.orderStateSubscription?.unsubscribe();
+  }
+
+  async enqueueFulfillmentTransition(
+    event: FulfillmentStateTransitionEvent,
+  ): Promise<void> {
+    if (
+      !["ReadyForPickup", "PickedUp", "Shipped", "Delivered"].includes(
+        event.toState,
+      )
+    ) {
+      return;
+    }
+    const orders = await this.connection.getRepository(event.ctx, Order).find({
+      where: { fulfillments: { id: event.fulfillment.id } },
+      relations: [...fulfillmentLifecycleOrderRelations],
+    });
+
+    for (const order of orders) {
+      const fulfillment = order.fulfillments.find(
+        (candidate) => String(candidate.id) === String(event.fulfillment.id),
+      );
+      if (!fulfillment) continue;
+      const shippingMethodCode = resolveShippingMethodCodeForOrderLines(
+        order.shippingLines.map((line) => ({
+          code: line.shippingMethod.code,
+          orderLineIds: line.orderLines.map((orderLine) => orderLine.id),
+        })),
+        fulfillment.lines.map((line) => line.orderLineId),
+      );
+      const kind = toFulfillmentLifecycleEmailKind(
+        shippingMethodCode,
+        event.toState,
+      );
+      if (!kind) continue;
+      if (!(await this.isEnabled(event.ctx, kind))) continue;
+      const identity = await this.getDeliveryIdentity(event.ctx, order);
+      const delivery = createPendingFulfillmentEmailDelivery({
+        orderId: Number(order.id),
+        kind,
+        snapshot: {
+          ...identity,
+          orderCode: order.code,
+          currencyCode: order.currencyCode,
+          totalWithTax: order.totalWithTax,
+          shippingWithTax: order.shippingWithTax,
+          shippingMethodCode,
+          fulfillmentId: String(fulfillment.id),
+          trackingCode: fulfillment.trackingCode ?? "",
+          lines: toEmailLineSnapshots(
+            order.lines,
+            fulfillment.lines,
+            identity.languageCode,
+          ),
+        },
+      });
+      await this.insertOnce(event.ctx, delivery);
+    }
+  }
+
+  async enqueueCancellation(event: HistoryEntryEvent): Promise<void> {
+    const input = toCancellationHistoryInput(event);
+    if (!input) return;
+    if (!(await this.isEnabled(event.ctx, "order-cancelled"))) return;
+
+    const orderId = (
+      event.entity as typeof event.entity & {
+        order?: { id?: string | number };
+      }
+    ).order?.id;
+    if (orderId === undefined) {
+      throw new Error("order cancellation history relation is missing");
+    }
+    const order = await this.connection
+      .getRepository(event.ctx, Order)
+      .findOne({
+        where: { id: orderId },
+        relations: [
+          "customer",
+          "lines.productVariant",
+          "lines.productVariant.translations",
+        ],
+      });
+    if (!order) return;
+
+    const identity = await this.getDeliveryIdentity(event.ctx, order);
+    const delivery = createPendingCancellationEmailDelivery({
+      orderId: Number(order.id),
+      snapshot: {
+        ...identity,
+        orderCode: order.code,
+        currencyCode: order.currencyCode,
+        totalWithTax: order.totalWithTax,
+        shippingWithTax: order.shippingWithTax,
+        historyEntryId: String(event.entity.id),
+        shippingCancelled: input.data.shippingCancelled,
+        lines: toEmailLineSnapshots(
+          order.lines,
+          input.data.lines,
+          identity.languageCode,
+        ),
+      },
+    });
+    await this.insertOnce(event.ctx, delivery);
+  }
+
+  async alignSettledCourierOrder(
+    event: OrderStateTransitionEvent,
+  ): Promise<void> {
+    const order = await this.connection.getEntityOrThrow(
+      event.ctx,
+      Order,
+      event.order.id,
+      {
+        relations: [
+          "lines",
+          "shippingLines.shippingMethod",
+          "fulfillments",
+          "fulfillments.lines",
+        ],
+      },
+    );
+    if (
+      order.shippingLines.some((line) => line.shippingMethod.code === "pickup")
+    ) {
+      return;
+    }
+    const targetState = getCourierOrderAlignmentState(
+      order.lines.map((line) => ({
+        orderLineId: line.id,
+        quantity: line.quantity,
+      })),
+      order.fulfillments.flatMap((fulfillment) =>
+        fulfillment.lines.map((line) => ({
+          orderLineId: line.orderLineId,
+          quantity: line.quantity,
+          state: fulfillment.state,
+        })),
+      ),
+    );
+    if (!targetState || targetState === order.state) return;
+
+    const result = await this.orderService.transitionToState(
+      event.ctx,
+      order.id,
+      targetState,
+    );
+    if (isGraphQlErrorResult(result)) {
+      throw new Error("settled courier order alignment failed");
+    }
+  }
+
+  private async getDeliveryIdentity(ctx: RequestContext, order: Order) {
+    const confirmationDelivery = await this.connection
+      .getRepository(ctx, JarShopOrderEmailDelivery)
+      .findOne({
+        where: {
+          orderId: Number(order.id),
+          kind: "order-confirmation",
+        },
+      });
+    if (confirmationDelivery) {
+      const payload = decryptOrderEmailOutboxPayload(
+        confirmationDelivery.payloadCiphertext,
+      );
+      if (isSnapshotOrderEmailOutboxPayload(payload)) {
+        return {
+          recipient: payload.snapshot.recipient,
+          languageCode: payload.snapshot.languageCode,
+        };
+      }
+    }
+    if (!order.customer?.emailAddress) {
+      throw new Error("order lifecycle email recipient is missing");
+    }
+    return {
+      recipient: order.customer.emailAddress,
+      languageCode: toOrderEmailLanguageCode(
+        confirmationDelivery?.languageCode ?? ctx.languageCode,
+      ),
+    };
+  }
+
+  private async isEnabled(
+    ctx: RequestContext,
+    kind: Parameters<typeof isLifecycleEmailEnabled>[1],
+  ): Promise<boolean> {
+    const configuration = await this.connection
+      .getRepository(ctx, JarShopEmailBrandConfiguration)
+      .findOne({ where: { channelId: Number(ctx.channelId) } });
+    return isLifecycleEmailEnabled(configuration, kind);
+  }
+
+  private async insertOnce(
+    ctx: RequestContext,
+    delivery: ReturnType<
+      | typeof createPendingFulfillmentEmailDelivery
+      | typeof createPendingCancellationEmailDelivery
+    >,
+  ): Promise<void> {
+    await this.connection
+      .getRepository(ctx, JarShopOrderEmailDelivery)
+      .createQueryBuilder()
+      .insert()
+      .values(delivery)
+      .orIgnore()
+      .execute();
+  }
+}
+
+export function toEmailLineSnapshots(
+  orderLines: readonly OrderLine[],
+  eventLines: ReadonlyArray<{
+    orderLineId: string | number;
+    quantity: number;
+  }>,
+  languageCode: string,
+): OrderEmailLineSnapshot[] {
+  return eventLines.map((eventLine) => {
+    const orderLine = orderLines.find(
+      (candidate) => String(candidate.id) === String(eventLine.orderLineId),
+    );
+    if (!orderLine) {
+      throw new Error("order lifecycle email line is missing");
+    }
+    return {
+      name: resolveLocalizedVariantName(
+        orderLine.productVariant.translations,
+        languageCode,
+      ),
+      quantity: eventLine.quantity,
+      totalWithTax: Math.round(
+        orderLine.proratedUnitPriceWithTax * eventLine.quantity,
+      ),
+    };
+  });
+}
+
+function toCancellationHistoryInput(
+  event: HistoryEntryEvent,
+): CancellationHistoryInput | undefined {
+  if (
+    event.historyType !== "order" ||
+    event.type !== "created" ||
+    typeof event.input !== "object" ||
+    event.input === null ||
+    !("type" in event.input) ||
+    event.input.type !== HistoryEntryType.ORDER_CANCELLATION ||
+    !("data" in event.input) ||
+    typeof event.input.data !== "object" ||
+    event.input.data === null ||
+    !("lines" in event.input.data) ||
+    !Array.isArray(event.input.data.lines) ||
+    !("shippingCancelled" in event.input.data) ||
+    typeof event.input.data.shippingCancelled !== "boolean"
+  ) {
+    return undefined;
+  }
+  return event.input as CancellationHistoryInput;
+}