Verification chase

// your signup handler
import { hs } from "./lib/hogsend.js";

await hs.emails.send({
  to: user.email,
  template: "transactional/verify-email",
  props: {
    firstName: user.firstName,
    verifyUrl: `https://app.example.com/verify?token=${token}`,
  },
});

await hs.events.send({
  name: "user.signed_up",
  email: user.email,
  userId: user.id,
  eventProperties: {
    first_name: user.firstName,
    // a re-link endpoint, not the raw token — it mints a fresh token on
    // click, so the second re-send still works after the original expires
    verify_url: `https://app.example.com/verify/resend?u=${user.id}`,
  },
  idempotencyKey: `signed-up-${user.id}`,
});

// your verify endpoint, after the token checks out
await hs.events.send({
  name: "user.email_verified",
  userId: user.id,
  idempotencyKey: `email-verified-${user.id}`,
});

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

export const verificationChase = defineJourney({
  meta: {
    id: "verification-chase",
    name: "Onboarding — verification chase",
    enabled: true,
    trigger: { event: Events.USER_SIGNED_UP },
    entryLimit: "once",
    suppress: hours(12),
    exitOn: [
      { event: Events.EMAIL_VERIFIED },
      { event: Events.USER_DELETED },
    ],
  },

  run: async (user, ctx) => {
    const verifyUrl = String(user.properties.verify_url ?? "");
    const firstName = String(user.properties.first_name ?? "");

    // The signup handler already sent the first verify-email. The lookback
    // catches a user who verified while this run was enrolling.
    const first = await ctx.waitForEvent({
      event: Events.EMAIL_VERIFIED,
      timeout: hours(24),
      label: "await-verification",
      lookback: minutes(30),
    });
    if (!first.timedOut) return; // verified — done

    // Re-send 1, after a day.
    if (!(await ctx.guard.isSubscribed())) return;
    await sendEmail({
      to: user.email,
      userId: user.id,
      journeyStateId: user.stateId,
      template: Templates.TRANSACTIONAL_VERIFY_EMAIL, // "transactional/verify-email"
      subject: "Reminder: verify your email address",
      journeyName: user.journeyName,
      props: { firstName, verifyUrl },
    });

    const second = await ctx.waitForEvent({
      event: Events.EMAIL_VERIFIED,
      timeout: days(2),
      label: "await-verification-2",
    });
    if (!second.timedOut) return;

    // Re-send 2 — the last one. An unverified account past this point is
    // your signup flow's problem, not email's.
    if (!(await ctx.guard.isSubscribed())) return;
    await sendEmail({
      to: user.email,
      userId: user.id,
      journeyStateId: user.stateId,
      template: Templates.TRANSACTIONAL_VERIFY_EMAIL,
      subject: "Last reminder — your account isn't active yet",
      journeyName: user.journeyName,
      props: { firstName, verifyUrl },
    });
  },
});

// src/journeys/constants/index.ts
export const Events = {
  USER_SIGNED_UP: "user.signed_up",
  EMAIL_VERIFIED: "user.email_verified",
  USER_DELETED: "user.deleted",
} as const;

export const Templates = {
  TRANSACTIONAL_VERIFY_EMAIL: "transactional/verify-email",
} as const;