Event reminder sequence

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

const HOUR = 60 * 60 * 1000;

export const eventReminderSequence = defineJourney({
  meta: {
    id: "event-reminder-sequence",
    name: "Webinar — reminder sequence",
    enabled: true,
    trigger: {
      event: Events.WEBINAR_REGISTERED,
      // a registration without a start time can't be scheduled against
      where: (b) => b.prop("start_time").exists(),
    },
    entryLimit: "unlimited",
    suppress: hours(1),
    exitOn: [{ event: Events.WEBINAR_CANCELLED }],
  },

  run: async (user, ctx) => {
    const title = String(user.properties.title ?? "the session");
    const startsAt = new Date(String(user.properties.start_time ?? ""));
    if (Number.isNaN(startsAt.getTime())) return; // unparseable — nothing to schedule

    // Confirm straight away.
    await sendEmail({
      to: user.email,
      userId: user.id,
      journeyStateId: user.stateId,
      template: Templates.WEBINAR_CONFIRMATION, // "webinar/confirmation"
      subject: "You're registered",
      journeyName: user.journeyName,
      props: { title },
    });

    // T-24h. Guard each reminder: sleepUntil resolves IMMEDIATELY for a past
    // instant, so without the check a late registration would get a stale
    // "starts tomorrow" email right now instead of skipping it.
    if (Date.now() < startsAt.getTime() - 24 * HOUR) {
      await ctx.sleepUntil(new Date(startsAt.getTime() - 24 * HOUR), {
        label: "t-24h",
      });
      if (!(await ctx.guard.isSubscribed())) return;
      await sendEmail({
        to: user.email,
        userId: user.id,
        journeyStateId: user.stateId,
        template: Templates.WEBINAR_REMINDER, // "webinar/reminder"
        subject: "Starts tomorrow",
        journeyName: user.journeyName,
        props: { title, hoursToGo: 24 },
      });
    }

    // T-1h — same guard, same template, different props.
    if (Date.now() < startsAt.getTime() - 1 * HOUR) {
      await ctx.sleepUntil(new Date(startsAt.getTime() - 1 * HOUR), {
        label: "t-1h",
      });
      if (!(await ctx.guard.isSubscribed())) return;
      await sendEmail({
        to: user.email,
        userId: user.id,
        journeyStateId: user.stateId,
        template: Templates.WEBINAR_REMINDER,
        subject: "Starting in an hour",
        journeyName: user.journeyName,
        props: { title, hoursToGo: 1 },
      });
    }

    // Did they show up? The wait resolves the instant webinar.joined lands;
    // lookback covers a join that arrived between the send and this wait.
    const joined = await ctx.waitForEvent({
      event: Events.WEBINAR_JOINED,
      timeout: hours(3),
      lookback: minutes(30),
      label: "await-join",
    });

    // Hold the follow-up until the session is over either way.
    await ctx.sleepUntil(new Date(startsAt.getTime() + 2 * HOUR), {
      label: "post-event",
    });
    if (!(await ctx.guard.isSubscribed())) return;

    if (joined.timedOut) {
      await sendEmail({
        to: user.email,
        userId: user.id,
        journeyStateId: user.stateId,
        template: Templates.WEBINAR_REPLAY, // "webinar/replay"
        subject: "Sorry we missed you — here's the replay",
        journeyName: user.journeyName,
        props: { title },
      });
    } else {
      await sendEmail({
        to: user.email,
        userId: user.id,
        journeyStateId: user.stateId,
        template: Templates.WEBINAR_THANKS, // "webinar/thanks"
        subject: "Thanks for joining",
        journeyName: user.journeyName,
        props: { title },
      });
    }
  },
});

// your app server
import { hs } from "./lib/hogsend.js";

// registration — starts the sequence
await hs.events.send({
  name: "webinar.registered",
  email: attendee.email,
  userId: attendee.id,
  eventProperties: {
    webinar_id: webinar.id,
    title: webinar.title,
    start_time: webinar.startsAt.toISOString(),
  },
  idempotencyKey: `webinar-reg-${webinar.id}-${attendee.id}`,
});

// they joined the live session — resolves the attendance wait
await hs.events.send({
  name: "webinar.joined",
  userId: attendee.id,
  eventProperties: { webinar_id: webinar.id },
});

// the webinar is called off — exits every registrant's run, even mid-sleep
await hs.events.send({
  name: "webinar.cancelled",
  userId: attendee.id,
  eventProperties: { webinar_id: webinar.id },
});

// src/journeys/constants/index.ts
export const Events = {
  WEBINAR_REGISTERED: "webinar.registered",
  WEBINAR_CANCELLED: "webinar.cancelled",
  WEBINAR_JOINED: "webinar.joined",
} as const;

export const Templates = {
  WEBINAR_CONFIRMATION: "webinar/confirmation",
  WEBINAR_REMINDER: "webinar/reminder",
  WEBINAR_THANKS: "webinar/thanks",
  WEBINAR_REPLAY: "webinar/replay",
} as const;