@jarwizz/create-jarshop 0.1.3 → 0.1.5

package/dist/template/src/plugins/jarshop-checkout/jarshop-checkout.plugin.ts

@@ -27,23 +27,34 @@ import {
   canExchangeConfirmationToken,
   canReadConfirmationCredential,
   createConfirmationToken,
+  createConfirmationTokenPair,
   hashConfirmationToken,
   readCookieValue,
 } from "./confirmation.js";
 import { JarShopLegalConfiguration } from "./legal.entity.js";
 import { JarShopOrderEmailDelivery } from "./order-email-delivery.entity.js";
+import { JarShopEmailBrandConfiguration } from "./order-email-configuration.entity.js";
+import {
+  normalizeOrderEmailBrandConfiguration,
+  toOrderEmailBrandConfiguration,
+  type OrderEmailBrandConfigurationInput,
+} from "./order-email-configuration.js";
+import { JarShopOrderEmailLifecycleOutbox } from "./order-email-lifecycle.js";
 import {
   isOrderAvailableInChannel,
   toOrderEmailDeliveryStatus,
 } from "./order-email-delivery-status.js";
 import { createPendingOrderEmailDelivery } from "./order-email-outbox.js";
+import { toOrderEmailLanguageCode } from "./order-email-delivery-core.js";
 import {
   JarShopOrderEmailWorker,
   registerJarShopOrderEmailWorkerTask,
 } from "./order-email-worker.js";
 import { JarShopOrderConsent } from "./order-consent.entity.js";
+import { registerJarShopOrderLifecycle } from "./order-lifecycle-process.js";
 import {
   compareCheckoutSnapshot,
+  resolveLocalizedShippingMethodName,
   validateShippingSelection,
   type CheckoutCartSnapshot,
   type ShippingAddressInput,
@@ -161,12 +172,47 @@ const adminSchema = parse(`
     sentAt: DateTime
     lastErrorCode: String
   }
+  type JarShopEmailShippingMethodConfiguration {
+    code: String!
+    pickupDetails: String!
+    trackingUrlTemplate: String!
+  }
+  input JarShopEmailShippingMethodConfigurationInput {
+    code: String!
+    pickupDetails: String!
+    trackingUrlTemplate: String!
+  }
+  type JarShopEmailBrandConfiguration {
+    brandName: String!
+    logoUrl: String
+    primaryColor: String!
+    websiteUrl: String!
+    supportEmail: String!
+    companyName: String!
+    companyAddress: String!
+    enabledEvents: [String!]!
+    shippingMethods: [JarShopEmailShippingMethodConfiguration!]!
+  }
+  input JarShopEmailBrandConfigurationInput {
+    brandName: String!
+    logoUrl: String
+    primaryColor: String!
+    websiteUrl: String!
+    supportEmail: String!
+    companyName: String!
+    companyAddress: String!
+    enabledEvents: [String!]!
+    shippingMethods: [JarShopEmailShippingMethodConfigurationInput!]!
+  }
   extend type Query {
     jarShopLegalConfiguration(languageCode: String!): JarShopLegalConfiguration
     jarShopOrderEmailDeliveryStatus(orderId: ID!): JarShopOrderEmailDeliveryStatus
+    jarShopOrderEmailDeliveries(orderId: ID!): [JarShopOrderEmailDeliveryStatus!]!
+    jarShopEmailBrandConfiguration: JarShopEmailBrandConfiguration
   }
   extend type Mutation {
     updateJarShopLegalConfiguration(input: JarShopLegalConfigurationInput!): JarShopLegalConfiguration!
+    updateJarShopEmailBrandConfiguration(input: JarShopEmailBrandConfigurationInput!): JarShopEmailBrandConfiguration!
   }
 `);
 
@@ -613,30 +659,74 @@ class JarShopCheckoutResolver {
         acceptedAt: new Date(),
       }),
     );
-    const confirmation = createConfirmationToken();
+    const confirmations = createConfirmationTokenPair();
     const tokenRepository = this.connection.getRepository(
       ctx,
       JarShopConfirmationToken,
     );
-    await tokenRepository.save(
+    await tokenRepository.save([
       tokenRepository.create({
-        tokenHash: confirmation.tokenHash,
+        tokenHash: confirmations.browser.tokenHash,
         orderId: Number(paymentResult.id),
-        expiresAt: confirmation.expiresAt,
+        expiresAt: confirmations.browser.expiresAt,
         consumedAt: null,
       }),
-    );
+      tokenRepository.create({
+        tokenHash: confirmations.email.tokenHash,
+        orderId: Number(paymentResult.id),
+        expiresAt: confirmations.email.expiresAt,
+        consumedAt: null,
+      }),
+    ]);
     const emailDeliveryRepository = this.connection.getRepository(
       ctx,
       JarShopOrderEmailDelivery,
     );
+    const orderEmailSnapshotSource = await this.orderService.findOne(
+      ctx,
+      paymentResult.id,
+      [
+        "customer",
+        "lines.productVariant",
+        "shippingLines.shippingMethod.translations",
+        "payments",
+      ],
+    );
+    if (!orderEmailSnapshotSource?.customer?.emailAddress) {
+      throw new Error("order confirmation snapshot is incomplete");
+    }
+    const orderEmailLanguageCode = toOrderEmailLanguageCode(input.languageCode);
     await emailDeliveryRepository.save(
       emailDeliveryRepository.create(
         createPendingOrderEmailDelivery({
           orderId: Number(paymentResult.id),
           checkoutAttemptId: attempt.attemptId,
-          languageCode: input.languageCode,
-          confirmationToken: confirmation.token,
+          snapshot: {
+            recipient: orderEmailSnapshotSource.customer.emailAddress,
+            languageCode: orderEmailLanguageCode,
+            orderCode: orderEmailSnapshotSource.code,
+            currencyCode: orderEmailSnapshotSource.currencyCode,
+            totalWithTax: orderEmailSnapshotSource.totalWithTax,
+            shippingWithTax: orderEmailSnapshotSource.shippingWithTax,
+            paymentMethod: orderEmailSnapshotSource.payments
+              .map((payment) => payment.method)
+              .join(", "),
+            shippingMethod: orderEmailSnapshotSource.shippingLines
+              .map((line) =>
+                resolveLocalizedShippingMethodName(
+                  line.shippingMethod,
+                  orderEmailLanguageCode,
+                ),
+              )
+              .filter(Boolean)
+              .join(", "),
+            confirmationToken: confirmations.email.token,
+            lines: orderEmailSnapshotSource.lines.map((line) => ({
+              name: line.productVariant.name,
+              quantity: line.quantity,
+              totalWithTax: Math.round(line.proratedLinePriceWithTax),
+            })),
+          },
         }),
       ),
     );
@@ -650,13 +740,13 @@ class JarShopCheckoutResolver {
           placedOrder,
           activeOrder.totalWithTax,
           activeOrder.currencyCode,
-          confirmation.token,
+          confirmations.browser.token,
         )
       : success(
           paymentResult,
           activeOrder.totalWithTax,
           activeOrder.currencyCode,
-          confirmation.token,
+          confirmations.browser.token,
         );
   }
 
@@ -721,10 +811,66 @@ class JarShopLegalAdminResolver {
 
     const delivery = await this.connection
       .getRepository(ctx, JarShopOrderEmailDelivery)
-      .findOne({ where: { orderId: parsedOrderId } });
+      .findOne({
+        where: { orderId: parsedOrderId, kind: "order-confirmation" },
+      });
     return delivery ? toOrderEmailDeliveryStatus(delivery) : null;
   }
 
+  @Query()
+  @Allow(Permission.ReadOrder)
+  async jarShopOrderEmailDeliveries(
+    @Ctx() ctx: RequestContext,
+    @Args("orderId") orderId: string,
+  ) {
+    const parsedOrderId = parsePositiveOrderId(orderId);
+    if (parsedOrderId === undefined) return [];
+    const order = await this.connection
+      .getRepository(ctx, Order)
+      .findOne({ where: { id: parsedOrderId }, relations: ["channels"] });
+    if (
+      !order ||
+      !isOrderAvailableInChannel(
+        order.channels.map((channel) => channel.id),
+        ctx.channelId,
+      )
+    ) {
+      return [];
+    }
+    const deliveries = await this.connection
+      .getRepository(ctx, JarShopOrderEmailDelivery)
+      .find({ where: { orderId: parsedOrderId }, order: { createdAt: "ASC" } });
+    return deliveries.map(toOrderEmailDeliveryStatus);
+  }
+
+  @Query()
+  @Allow(Permission.UpdateSettings)
+  async jarShopEmailBrandConfiguration(@Ctx() ctx: RequestContext) {
+    const configuration = await this.connection
+      .getRepository(ctx, JarShopEmailBrandConfiguration)
+      .findOne({ where: { channelId: Number(ctx.channelId) } });
+    return configuration ? toOrderEmailBrandConfiguration(configuration) : null;
+  }
+
+  @Mutation()
+  @Allow(Permission.UpdateSettings)
+  async updateJarShopEmailBrandConfiguration(
+    @Ctx() ctx: RequestContext,
+    @Args("input") input: OrderEmailBrandConfigurationInput,
+  ) {
+    const normalized = normalizeOrderEmailBrandConfiguration(input);
+    const repository = this.connection.getRepository(
+      ctx,
+      JarShopEmailBrandConfiguration,
+    );
+    let configuration = await repository.findOne({
+      where: { channelId: Number(ctx.channelId) },
+    });
+    configuration ??= repository.create({ channelId: Number(ctx.channelId) });
+    Object.assign(configuration, normalized);
+    return toOrderEmailBrandConfiguration(await repository.save(configuration));
+  }
+
   @Mutation()
   @Allow(Permission.UpdateSettings)
   async updateJarShopLegalConfiguration(
@@ -849,13 +995,15 @@ function toOrderConfirmation(order: Order) {
 @VendurePlugin({
   dashboard: "./dashboard/index.tsx",
   imports: [PluginCommonModule],
-  providers: [JarShopOrderEmailWorker],
-  configuration: registerJarShopOrderEmailWorkerTask,
+  providers: [JarShopOrderEmailLifecycleOutbox, JarShopOrderEmailWorker],
+  configuration: (config) =>
+    registerJarShopOrderEmailWorkerTask(registerJarShopOrderLifecycle(config)),
   entities: [
     CheckoutAttempt,
     JarShopConfirmationToken,
     JarShopLegalConfiguration,
     JarShopOrderEmailDelivery,
+    JarShopEmailBrandConfiguration,
     JarShopOrderConsent,
   ],
   shopApiExtensions: {

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

@@ -0,0 +1,61 @@
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  PrimaryGeneratedColumn,
+  Unique,
+  UpdateDateColumn,
+} from "typeorm";
+import type { FulfillmentLifecycleEmailKind } from "./order-email-outbox.js";
+
+export type ConfigurableOrderEmailKind =
+  FulfillmentLifecycleEmailKind | "order-cancelled";
+
+export type OrderEmailShippingMethodConfiguration = {
+  code: string;
+  pickupDetails: string;
+  trackingUrlTemplate: string;
+};
+
+@Entity({ name: "jarshop_email_brand_configuration" })
+@Unique("UQ_jarshop_email_brand_configuration_channel", ["channelId"])
+export class JarShopEmailBrandConfiguration {
+  @PrimaryGeneratedColumn()
+  id!: number;
+
+  @Column({ type: "int" })
+  channelId!: number;
+
+  @Column({ type: "varchar", length: 120 })
+  brandName!: string;
+
+  @Column({ type: "varchar", length: 2_048, nullable: true })
+  logoUrl!: string | null;
+
+  @Column({ type: "varchar", length: 7 })
+  primaryColor!: string;
+
+  @Column({ type: "varchar", length: 2_048 })
+  websiteUrl!: string;
+
+  @Column({ type: "varchar", length: 320 })
+  supportEmail!: string;
+
+  @Column({ type: "varchar", length: 160 })
+  companyName!: string;
+
+  @Column({ type: "text" })
+  companyAddress!: string;
+
+  @Column({ type: "jsonb", default: () => "'[]'::jsonb" })
+  enabledEvents!: ConfigurableOrderEmailKind[];
+
+  @Column({ type: "jsonb", default: () => "'[]'::jsonb" })
+  shippingMethods!: OrderEmailShippingMethodConfiguration[];
+
+  @CreateDateColumn()
+  createdAt!: Date;
+
+  @UpdateDateColumn()
+  updatedAt!: Date;
+}

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

@@ -0,0 +1,190 @@
+import type {
+  ConfigurableOrderEmailKind,
+  JarShopEmailBrandConfiguration,
+  OrderEmailShippingMethodConfiguration,
+} from "./order-email-configuration.entity.js";
+
+const configurableOrderEmailKinds = [
+  "pickup-ready",
+  "pickup-picked-up",
+  "shipment-shipped",
+  "shipment-delivered",
+  "order-cancelled",
+] as const satisfies readonly ConfigurableOrderEmailKind[];
+
+export type OrderEmailBrandConfigurationInput = {
+  brandName: string;
+  logoUrl?: string | null;
+  primaryColor: string;
+  websiteUrl: string;
+  supportEmail: string;
+  companyName: string;
+  companyAddress: string;
+  enabledEvents: string[];
+  shippingMethods: OrderEmailShippingMethodConfiguration[];
+};
+
+export function validateOrderEmailBrandConfiguration(
+  input: OrderEmailBrandConfigurationInput,
+): void {
+  requireText(input.brandName, "brandName", 120);
+  requireText(input.companyName, "companyName", 160);
+  requireText(input.companyAddress, "companyAddress", 1_000);
+  requireEmail(input.supportEmail);
+  requireSafeUrl(input.websiteUrl, "websiteUrl");
+  if (input.logoUrl) requireSafeUrl(input.logoUrl, "logoUrl");
+  if (!/^#[0-9a-f]{6}$/iu.test(input.primaryColor)) {
+    throw new Error("primaryColor must use #RRGGBB");
+  }
+
+  const enabledEvents = new Set(input.enabledEvents);
+  if (
+    enabledEvents.size !== input.enabledEvents.length ||
+    [...enabledEvents].some(
+      (kind) => !configurableOrderEmailKinds.includes(kind as never),
+    )
+  ) {
+    throw new Error("enabledEvents contains an unsupported or duplicate kind");
+  }
+
+  const methodCodes = new Set<string>();
+  for (const method of input.shippingMethods) {
+    requireText(method.code, "shippingMethods.code", 64);
+    if (methodCodes.has(method.code)) {
+      throw new Error("shippingMethods contains a duplicate code");
+    }
+    methodCodes.add(method.code);
+    requireOptionalText(
+      method.pickupDetails,
+      "shippingMethods.pickupDetails",
+      1_000,
+    );
+    if (method.trackingUrlTemplate) {
+      validateTrackingUrlTemplate(method.trackingUrlTemplate);
+    }
+  }
+
+  if (
+    (enabledEvents.has("pickup-ready") ||
+      enabledEvents.has("pickup-picked-up")) &&
+    !input.shippingMethods.some(
+      (method) => method.code === "pickup" && method.pickupDetails.trim(),
+    )
+  ) {
+    throw new Error("pickup lifecycle email requires pickup method details");
+  }
+}
+
+export function normalizeOrderEmailBrandConfiguration(
+  input: OrderEmailBrandConfigurationInput,
+): OrderEmailBrandConfigurationInput {
+  validateOrderEmailBrandConfiguration(input);
+  return {
+    brandName: input.brandName.trim(),
+    logoUrl: input.logoUrl?.trim() || null,
+    primaryColor: input.primaryColor.toLowerCase(),
+    websiteUrl: input.websiteUrl.trim(),
+    supportEmail: input.supportEmail.trim().toLowerCase(),
+    companyName: input.companyName.trim(),
+    companyAddress: input.companyAddress.trim(),
+    enabledEvents: [...input.enabledEvents] as ConfigurableOrderEmailKind[],
+    shippingMethods: input.shippingMethods.map((method) => ({
+      code: method.code.trim(),
+      pickupDetails: method.pickupDetails.trim(),
+      trackingUrlTemplate: method.trackingUrlTemplate.trim(),
+    })),
+  };
+}
+
+export function isLifecycleEmailEnabled(
+  configuration: JarShopEmailBrandConfiguration | null | undefined,
+  kind: ConfigurableOrderEmailKind,
+): configuration is JarShopEmailBrandConfiguration {
+  return configuration?.enabledEvents.includes(kind) ?? false;
+}
+
+export function resolveShippingEmailConfiguration(
+  configuration: JarShopEmailBrandConfiguration,
+  code: string,
+): OrderEmailShippingMethodConfiguration | undefined {
+  return configuration.shippingMethods.find((method) => method.code === code);
+}
+
+export function createTrackingUrl(
+  template: string,
+  trackingCode: string,
+): string | undefined {
+  if (!template || !trackingCode) return undefined;
+  validateTrackingUrlTemplate(template);
+  return template.replace(
+    "{trackingCode}",
+    encodeURIComponent(trackingCode.trim()),
+  );
+}
+
+export function validateTrackingUrlTemplate(template: string): void {
+  if (
+    template.split("{trackingCode}").length !== 2 ||
+    /[\r\n]/u.test(template)
+  ) {
+    throw new Error(
+      "trackingUrlTemplate must contain one {trackingCode} placeholder",
+    );
+  }
+  requireSafeUrl(
+    template.replace("{trackingCode}", "TRACKING"),
+    "trackingUrlTemplate",
+  );
+}
+
+export function toOrderEmailBrandConfiguration(
+  configuration: JarShopEmailBrandConfiguration,
+) {
+  return {
+    brandName: configuration.brandName,
+    logoUrl: configuration.logoUrl,
+    primaryColor: configuration.primaryColor,
+    websiteUrl: configuration.websiteUrl,
+    supportEmail: configuration.supportEmail,
+    companyName: configuration.companyName,
+    companyAddress: configuration.companyAddress,
+    enabledEvents: configuration.enabledEvents,
+    shippingMethods: configuration.shippingMethods,
+  };
+}
+
+function requireSafeUrl(value: string, field: string): void {
+  requireText(value, field, 2_048);
+  const url = new URL(value);
+  if (
+    url.protocol !== "https:" ||
+    url.username ||
+    url.password ||
+    url.origin === "null"
+  ) {
+    throw new Error(`${field} must be an absolute credential-free HTTPS URL`);
+  }
+}
+
+function requireEmail(value: string): void {
+  requireText(value, "supportEmail", 320);
+  if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/u.test(value)) {
+    throw new Error("supportEmail must be a valid email address");
+  }
+}
+
+function requireOptionalText(value: string, field: string, maximum: number) {
+  if (!value) return;
+  requireText(value, field, maximum);
+}
+
+function requireText(value: string, field: string, maximum: number): void {
+  const normalized = value.trim();
+  if (
+    !normalized ||
+    normalized.length > maximum ||
+    /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/u.test(normalized)
+  ) {
+    throw new Error(`${field} is invalid`);
+  }
+}