Support follow-up

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

export const supportFollowup = defineJourney({
  meta: {
    id: "support-followup",
    name: "Support — resolution follow-up",
    enabled: true,
    trigger: { event: Events.TICKET_RESOLVED },
    // a heavy support week is one follow-up, not three
    entryLimit: "once_per_period",
    entryPeriod: days(7),
    suppress: hours(12),
    // reopened through normal support channels — the question is moot.
    // The awaited support.followup_answered event must NEVER appear here.
    exitOn: [{ event: Events.TICKET_REOPENED }],
  },

  run: async (user, ctx) => {
    const ticketId = String(user.properties.ticket_id ?? "");

    // Land the question the next morning in the customer's timezone —
    // not thirty seconds after the agent hits "resolve".
    await ctx.sleepUntil(ctx.when.tomorrow().at("09:00"), {
      label: "next-morning",
    });
    if (!(await ctx.guard.isSubscribed())) return;

    await sendEmail({
      to: user.email,
      userId: user.id,
      journeyStateId: user.stateId,
      template: Templates.SUPPORT_FOLLOWUP, // "support/followup"
      subject: "Did that fix it?",
      journeyName: user.journeyName,
      props: { ticketId },
    });

    // The yes/no buttons are semantic links: the click is the answer,
    // confirmed ~30s after the click (scanner bursts suppressed). lookback
    // covers an answer landing between the send and this wait.
    const answer = await ctx.waitForEvent({
      event: Events.SUPPORT_FOLLOWUP_ANSWERED,
      timeout: days(4),
      label: "await-answer",
      lookback: minutes(30),
    });

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

    if (answer.properties?.answer === "no") {
      // The reopen request is a real event: the support-alert task
      // (onEvents) pages the queue, destinations receive it, and another
      // journey could trigger on it.
      await ctx.trigger({
        event: Events.SUPPORT_REOPEN_REQUESTED,
        userId: user.id,
        properties: {
          ticket_id: ticketId,
          source: "followup-email",
          answeredAt: new Date().toISOString(),
        },
      });
    }
    // "yes" ends the run — the answer is already in user_events and at
    // every destination for CSAT reporting.
  },
});

// src/emails/support/followup.tsx — the answer buttons
import { EmailAction, HOSTED_ANSWER_HREF } from "@hogsend/email";
import { Events } from "../../journeys/constants/index.js";

<Section className="my-6 text-center">
  <EmailAction
    event={Events.SUPPORT_FOLLOWUP_ANSWERED}
    properties={{ answer: "yes" }}
    href={HOSTED_ANSWER_HREF}
    className="mx-1 inline-block rounded-lg border px-5 py-2"
  >
    Yes, all sorted
  </EmailAction>
  <EmailAction
    event={Events.SUPPORT_FOLLOWUP_ANSWERED}
    properties={{ answer: "no" }}
    href={HOSTED_ANSWER_HREF}
    className="mx-1 inline-block rounded-lg border px-5 py-2"
  >
    No, still broken
  </EmailAction>
</Section>

// src/workflows/support-alert.ts
import type { JsonValue } from "@hatchet-dev/typescript-sdk/v1/types.js";
import { hatchet } from "@hogsend/engine";
import { getContainer } from "../container.js";
import { Events, Templates } from "../journeys/constants/index.js";

/** The support queue inbox — operational mail, never a contact. */
const SUPPORT_INBOX = process.env.SUPPORT_ALERT_EMAIL ?? "support@example.com";

/** The ingest pipeline's Hatchet push payload. */
interface ReopenRequestedInput {
  userId: JsonValue;
  userEmail: JsonValue;
  properties: JsonValue;
  [key: string]: JsonValue;
}

export const supportAlertTask = hatchet.durableTask({
  name: "support-alert",
  onEvents: [Events.SUPPORT_REOPEN_REQUESTED],
  retries: 2,
  executionTimeout: "15m",
  fn: async (input: ReopenRequestedInput) => {
    const { emailService } = getContainer();

    const userId = typeof input.userId === "string" ? input.userId : "";
    if (!userId) return { status: "skipped", reason: "missing_user_id" };
    const customerEmail =
      typeof input.userEmail === "string" ? input.userEmail : userId;

    const props = (input.properties ?? {}) as Record<
      string,
      string | number | boolean | null
    >;
    const ticketId = String(props.ticket_id ?? "unknown");
    const answeredAt = String(props.answeredAt ?? new Date().toISOString());

    const result = await emailService.send({
      template: Templates.TRANSACTIONAL_SUPPORT_ALERT, // "transactional/support-alert"
      to: SUPPORT_INBOX,
      subject: `[Reopen requested] #${ticketId} — ${customerEmail}`,
      props: { ticketId, customerEmail, answeredAt },
      // Registry "transactional" wins (no category override), and the
      // customer's unsubscribe state never gates operator mail.
      skipPreferenceCheck: true,
      // A task retry after a successful send short-circuits — no double page.
      idempotencyKey: `support-alert:${userId}:${ticketId}:${answeredAt}`,
    });
    return { status: result.status };
  },
});

// from your support tooling, when closing the loop
await hs.contacts.upsert({
  userId: customer.id,
  properties: { last_csat: "positive" },
});

// src/journeys/constants/index.ts
export const Events = {
  TICKET_RESOLVED: "ticket.resolved",
  TICKET_REOPENED: "ticket.reopened",
  SUPPORT_FOLLOWUP_ANSWERED: "support.followup_answered",
  SUPPORT_REOPEN_REQUESTED: "support.reopen_requested",
} as const;

export const Templates = {
  SUPPORT_FOLLOWUP: "support/followup",
  TRANSACTIONAL_SUPPORT_ALERT: "transactional/support-alert",
} as const;