Review request

// src/journeys/review-request.ts
import { days, hours, minutes } from "@hogsend/engine";
import { defineJourney, sendEmail } from "@hogsend/engine";
import { Events, Templates } from "./constants/index.js";

export const reviewRequest = defineJourney({
  meta: {
    id: "review-request",
    name: "E-commerce — review request",
    enabled: true,
    trigger: { event: Events.DELIVERY_CONFIRMED },
    // one ask per shopper per month, however many orders deliver
    entryLimit: "once_per_period",
    entryPeriod: days(30),
    suppress: hours(24),
    // a refund cancels the ask. REVIEW_RATED must never appear here —
    // the journey awaits it below.
    exitOn: [{ event: Events.ORDER_REFUNDED }],
  },

  run: async (user, ctx) => {
    const orderId = String(user.properties.order_id ?? "");
    const productName = String(user.properties.product_name ?? "your order");

    // Three days of actually using the product before asking.
    await ctx.sleep({ duration: days(3), label: "post-delivery" });
    if (!(await ctx.guard.isSubscribed())) return;

    await sendEmail({
      to: user.email,
      userId: user.id,
      journeyStateId: user.stateId,
      template: Templates.ECOMMERCE_REVIEW_REQUEST, // "ecommerce/review-request"
      subject: `How is ${productName} working out?`,
      journeyName: user.journeyName,
      props: { orderId, productName },
    });

    // The stars in the email are semantic links — a click fires
    // review.rated { rating }. lookback covers the gap between the send
    // and this wait being established.
    const answer = await ctx.waitForEvent({
      event: Events.REVIEW_RATED,
      timeout: days(7),
      label: "await-rating",
      lookback: minutes(30),
    });

    if (answer.timedOut) return; // no answer — leave them be

    const rating = Number(answer.properties?.rating ?? 0);

    if (rating <= 3) {
      // Unhappy — flag support instead of asking for a public review.
      await ctx.trigger({
        event: Events.REVIEW_NEEDS_FOLLOWUP,
        userId: user.id,
        properties: { order_id: orderId, rating, source: "review-request" },
      });
      return;
    }

    if (!(await ctx.guard.isSubscribed())) return;

    // Happy — now ask for the public review.
    await sendEmail({
      to: user.email,
      userId: user.id,
      journeyStateId: user.stateId,
      template: Templates.ECOMMERCE_REVIEW_PUBLIC_ASK, // "ecommerce/review-public-ask"
      subject: "Would you share that in a review?",
      journeyName: user.journeyName,
      props: { orderId, productName, rating },
    });
  },
});

// src/emails/ecommerce/review-request.tsx — the rating row
import { EmailAction, HOSTED_ANSWER_HREF } from "@hogsend/email";
import { Events } from "../../journeys/constants/index.js";

{[1, 2, 3, 4, 5].map((rating) => (
  <EmailAction
    key={rating}
    event={Events.REVIEW_RATED}
    properties={{ rating }}
    href={HOSTED_ANSWER_HREF}
    className="mx-1 inline-block rounded-lg border px-4 py-2"
  >
    {"★".repeat(rating)}
  </EmailAction>
))}

// src/journeys/constants/index.ts — additions
export const Events = {
  DELIVERY_CONFIRMED: "delivery.confirmed",
  ORDER_REFUNDED: "order.refunded",
  REVIEW_RATED: "review.rated",
  REVIEW_NEEDS_FOLLOWUP: "review.needs_followup",
} as const;

export const Templates = {
  ECOMMERCE_REVIEW_REQUEST: "ecommerce/review-request",
  ECOMMERCE_REVIEW_PUBLIC_ASK: "ecommerce/review-public-ask",
} as const;