Link a Discord account to an email

import {
  createColdConnect,
  getEmailService,
} from "@hogsend/engine";
import {
  createDiscordConnector,
  DISCORD_PROVIDER_ID,
} from "@hogsend/plugin-discord";

// The cold-connect flow — the same engine primitive Telegram uses. It owns the
// sealed single-use token, the connect page, and the bind exchange.
export const discordColdConnect = createColdConnect<Record<string, never>>({
  connectorId: DISCORD_PROVIDER_ID,
  identityKind: "discordId",
  // The dedicated `discord_id` column keys on the RAW snowflake — no namespace
  // prefix (the engine has a collision guard on that column).
  platformKey: (id) => id,
  linkedEvent: "discord.linked",
  identifyPropKey: "discord_id",
  buildIngest: (binding) => ({
    // Scalar trigger properties a `discord.linked` welcome journey reads off
    // `user.properties.*` — `contactProperties` never reach the Hatchet payload.
    eventProperties: {
      source: "discord",
      discordId: binding.platformUserId,
      via: "email_confirm",
    },
    // `discord` is a deep-merge key, so this never clobbers the richer metadata
    // (username/avatar/etc.) inbound gateway events set.
    contactProperties: { discord: { id: binding.platformUserId } },
  }),
  branding: {
    iconSvg: DISCORD_ICON_SVG, // the real Discord mark, accent-tinted chip
    accentColor: "#5865f2",
    title: "Connect your Discord",
    blurb: "Tap below to finish linking your Discord account to your contact.",
    reassurance:
      "Didn't start this in Discord? You can safely close this tab — nothing " +
      "links to your account until you tap Confirm above.",
    // successCopy / errorCopy …
  },
});

export const discordConnector = createDiscordConnector({
  applicationId: env.DISCORD_APPLICATION_ID,
  clientSecret: env.DISCORD_CLIENT_SECRET,
  publicKeyHex: env.DISCORD_PUBLIC_KEY,
  redirectUri: `${base}/v1/connectors/discord/oauth/callback`,
  studioIntegrationsUrl: `${base}/studio/integrations`,
  saveDerived: async (patch) => {
    /* read-merge-write into the derived credential */
  },
  // discord_id is the SOLE merge key. Goes through `client.identity.linkContact`
  // (NOT bare resolveOrCreateContact) so the contact-merge propagates the PostHog
  // merge through the SAME engine path ingest uses.
  resolveContact: async (patch) => {
    await client.identity.linkContact({
      discordId: patch.discordId,
      email: patch.email, // the AUTHORITATIVE address the link was issued for
      contactProperties: patch.contactProperties,
    });
  },
  // The /link front door: mint a server-sealed cold-connect token (the throttle
  // runs FIRST inside mintConfirm) and, only on ok:true, email the one-click
  // confirm LINK. The handler never sees the token — it lives only in the URL.
  requestConfirm: async ({ discordUserId, email }) => {
    const minted = await discordColdConnect.mintConfirm({
      platformUserId: discordUserId,
      email,
    });
    if (!minted.ok) {
      return {
        ok: false,
        reason:
          minted.reason === "redis_unavailable" ? "unavailable" : "rate_limited",
      };
    }
    const url = discordColdConnect.confirmUrl({ apiPublicUrl: base, token: minted.token });
    // TRANSACTIONAL send — skipPreferenceCheck so a confirm link is NEVER dropped
    // by unsubscribe/frequency suppression. No contact exists yet, so userId is
    // the email (the exchange later folds discord_id + email onto one contact).
    await getEmailService().send({
      template: "transactional/magic-link",
      props: { magicLinkUrl: url, expiresIn: "15 minutes" },
      to: email,
      userId: email,
      userEmail: email,
      subject: "Confirm your Discord connection",
      category: "transactional",
      skipPreferenceCheck: true,
    });
    return { ok: true };
  },
});

const app = createApp(client, {
  webhookSources,
  routes: [
    telegramColdConnect.routes,
    ...(discordConnector ? [discordColdConnect.routes] : []),
  ],
});

// src/journeys/react-to-linked-state.ts
import { contacts } from "@hogsend/db";
import { days, defineJourney, getDb, hours, sendEmail } from "@hogsend/engine";
import { eq } from "drizzle-orm";
import { Events, Templates } from "./constants/index.js";

export const reactToLinkedState = defineJourney({
  meta: {
    id: "react-to-linked-state",
    name: "Discord — react to link state",
    enabled: true,
    trigger: { event: Events.DISCORD_MESSAGE_SENT }, // "discord.message_sent"
    entryLimit: "once_per_period",
    entryPeriod: days(7),
    suppress: hours(12),
  },

  run: async (user, ctx) => {
    const db = getDb();
    const contact = await db.query.contacts.findFirst({
      where: eq(contacts.id, user.id),
    });

    const meta = (contact?.properties?.discord ?? {}) as {
      username?: string;
    };

    if (!contact?.email) {
      // Discord-only — no address. Nudge to link via the channel.
      await ctx.trigger({
        event: Events.DISCORD_NUDGE_LINK,
        userId: user.id,
        properties: { username: meta.username ?? null },
      });
      return;
    }

    await sendEmail({
      to: contact.email,
      userId: user.id,
      journeyStateId: user.stateId,
      template: Templates.DISCORD_ACTIVE_THANKS,
      subject: `Thanks for being active, ${meta.username ?? "friend"}`,
      journeyName: user.journeyName,
    });
  },
});