Skip to content

armgit / kaneo

Public Imported from GitHub
0

⚡ Project management that doesn't become the project. Boards, Gantt charts, and GitHub integration. Self-host it or use Kaneo Cloud.

3.6 KB
Raw Blame
import { and, between, eq, isNotNull, isNull, ne, or } from "drizzle-orm";
import db from "../database";
import {
  columnTable,
  integrationTable,
  taskReminderSentTable,
  taskTable,
} from "../database/schema";
import {
  type GenericWebhookConfig,
  normalizeGenericWebhookConfig,
} from "../plugins/generic-webhook/config";
import { sendDueDateReminder } from "../plugins/generic-webhook/events";
import {
  DUE_DATE_DURATION_MS,
  REMINDER_WINDOW_MINUTES,
} from "./reminder-timing";
import { activeIntegrationCondition } from "../plugins/active-integration-condition";

const MINUTE_MS = 60 * 1000;

export async function checkProjectWebhookReminders(): Promise<{
  degraded: boolean;
}> {
  const now = new Date();
  const integrations = await db
    .select({
      id: integrationTable.id,
      projectId: integrationTable.projectId,
      config: integrationTable.config,
    })
    .from(integrationTable)
    .where(
      and(
        eq(integrationTable.type, "generic-webhook"),
        activeIntegrationCondition(),
      ),
    );
  let degraded = false;

  for (const integration of integrations) {
    try {
      const config = normalizeGenericWebhookConfig(
        JSON.parse(integration.config) as GenericWebhookConfig,
      );
      if (!config.events?.dueDateReminder) continue;

      const leadTimeMinutes = config.dueDateReminderLeadTimeMinutes ?? 1440;
      // Count back from expiration while keeping the indexed due date unmodified.
      const windowEnd = new Date(
        now.getTime() + leadTimeMinutes * MINUTE_MS - DUE_DATE_DURATION_MS,
      );
      const windowStart = new Date(
        windowEnd.getTime() - REMINDER_WINDOW_MINUTES * MINUTE_MS,
      );
      const reminderType = `generic_webhook:${integration.id}`;
      const tasks = await db
        .select({ id: taskTable.id, dueDate: taskTable.dueDate })
        .from(taskTable)
        .leftJoin(columnTable, eq(taskTable.columnId, columnTable.id))
        .leftJoin(
          taskReminderSentTable,
          and(
            eq(taskReminderSentTable.taskId, taskTable.id),
            eq(taskReminderSentTable.reminderType, reminderType),
          ),
        )
        .where(
          and(
            eq(taskTable.projectId, integration.projectId),
            isNotNull(taskTable.dueDate),
            between(taskTable.dueDate, windowStart, windowEnd),
            isNull(taskReminderSentTable.id),
            or(isNull(columnTable.isFinal), eq(columnTable.isFinal, false)),
            ne(taskTable.status, "archived"),
          ),
        );

      for (const task of tasks) {
        if (!task.dueDate) continue;

        const [sentRecord] = await db
          .insert(taskReminderSentTable)
          .values({ taskId: task.id, reminderType })
          .onConflictDoNothing({
            target: [
              taskReminderSentTable.taskId,
              taskReminderSentTable.reminderType,
            ],
          })
          .returning({ id: taskReminderSentTable.id });
        if (!sentRecord) continue;

        const delivered = await sendDueDateReminder(
          config,
          task.id,
          integration.projectId,
          leadTimeMinutes,
          task.dueDate,
        );

        if (!delivered) {
          await db
            .delete(taskReminderSentTable)
            .where(eq(taskReminderSentTable.id, sentRecord.id));
        }
      }
    } catch (error) {
      degraded = true;
      console.error("Failed to process project webhook reminder", {
        integrationId: integration.id,
        projectId: integration.projectId,
        error,
      });
    }
  }

  return { degraded };
}