Skip to content

Rallly is an open-source scheduling and collaboration tool designed to make organizing events and meetings easier.

4.5 KB
Raw Blame
import "server-only";

import { prisma } from "@rallly/database";
import { sendReviewRequestEmail } from "@rallly/emails/templates/review-request";
import { createLogger } from "@rallly/logger";
import { Effect } from "effect";
import { getInstanceBranding } from "@/emails/branding";
import { queueEmails } from "@/features/email-queue/mutations";
import {
  QueuedEmailFailed,
  QueuedEmailSkipped,
} from "@/features/email-queue/service";
import { isFeatureEnabled } from "@/lib/feature-flags/server";
import { track } from "@/lib/posthog";
import {
  reviewRequestEmailDelayMs,
  reviewRequestSender,
  reviewSites,
} from "./constants";
import { countFinalizedPolls, getReviewRequestRecipient } from "./data";
import {
  getFirstName,
  getReviewGuidelinesUrl,
  isEligibleForReviewRequest,
  pickReviewSite,
} from "./utils";

const logger = createLogger("review-request");

/**
 * Decides whether the user should be asked for a review after finalizing a
 * poll, and if so queues the email and records the ask so it is sent once per
 * user. Never throws: it runs after the poll is already finalized, so a
 * failure here must not fail the finalize request.
 */
export async function queueReviewRequest(params: {
  userId: string;
  participantCount: number;
}) {
  try {
    await queueReviewRequestOrThrow(params);
  } catch (error) {
    logger.error({ error, userId: params.userId }, "Review request failed");
  }
}

async function queueReviewRequestOrThrow({
  userId,
  participantCount,
}: {
  userId: string;
  participantCount: number;
}) {
  if (!isFeatureEnabled("reviewRequests")) {
    return;
  }

  const finalizedPollCount = await countFinalizedPolls(userId);

  if (!isEligibleForReviewRequest({ finalizedPollCount, participantCount })) {
    return;
  }

  const queued = await prisma.$transaction(async (tx) => {
    // Conditional on the column being unset, so two finalizations racing
    // each other still ask only once.
    const { count } = await tx.user.updateMany({
      where: { id: userId, reviewRequestedAt: null },
      data: { reviewRequestedAt: new Date() },
    });
    if (count === 0) {
      return false;
    }
    await queueEmails(tx, {
      kind: "review_request",
      userId,
      batchId: userId,
      subjectIds: [userId],
      sendAfter: new Date(Date.now() + reviewRequestEmailDelayMs),
    });
    return true;
  });

  if (queued) {
    track(
      { id: userId, isGuest: false },
      {
        event: "review_request:email_queue",
        properties: {
          finalized_poll_count: finalizedPollCount,
          participant_count: participantCount,
        },
      },
    );
  }
}

const failWith = (message: string) => () => new QueuedEmailFailed({ message });

/**
 * Sends the review request email queued by `queueReviewRequest`. The subject
 * is the user. The site is picked at send time, so a change to the routing
 * applies to emails already queued.
 */
export const sendReviewRequest = Effect.fn("reviewRequest.sendReviewRequest")(
  function* ({ subjectId }: { id: string; subjectId: string }) {
    const user = yield* Effect.tryPromise({
      try: () => getReviewRequestRecipient(subjectId),
      catch: failWith("Failed to load the user"),
    });
    if (!user || user.deletedAt) {
      return yield* new QueuedEmailSkipped({ reason: "User no longer exists" });
    }
    if (user.banned) {
      return yield* new QueuedEmailSkipped({ reason: "User is banned" });
    }

    const site = pickReviewSite({ userId: subjectId, email: user.email });
    const branding = yield* Effect.tryPromise({
      try: () => getInstanceBranding(),
      catch: failWith("Failed to load branding"),
    });

    // The mailer logs and swallows transport failures, so its result is what
    // tells a sent email from a failed one.
    const sent = yield* Effect.tryPromise({
      try: () =>
        sendReviewRequestEmail({
          to: user.email,
          locale: user.locale ?? undefined,
          branding,
          from: reviewRequestSender,
          props: {
            firstName: getFirstName(user.name),
            siteName: reviewSites[site].name,
            reviewUrl: reviewSites[site].url,
            guidelinesUrl: getReviewGuidelinesUrl(site),
          },
        }),
      catch: failWith("Failed to send the review request email"),
    });
    if (!sent) {
      return yield* new QueuedEmailFailed({ message: "Transport failed" });
    }

    track(
      { id: subjectId, isGuest: false },
      {
        event: "review_request:email_send",
        properties: { destination: site },
      },
    );
  },
);