alerts.ts

import {
  displayTypeSupportsRawSqlAlerts,
  validateRawSqlForAlert,
} from '@hyperdx/common-utils/dist/core/utils';
import { isRawSqlSavedChartConfig } from '@hyperdx/common-utils/dist/guards';
import { sign, verify } from 'jsonwebtoken';
import { groupBy } from 'lodash';
import ms from 'ms';
import { z } from 'zod';

import type { ObjectId } from '@/models';
import Alert, {
  AlertChannel,
  AlertInterval,
  AlertSource,
  AlertThresholdType,
  IAlert,
} from '@/models/alert';
import Dashboard, { IDashboard } from '@/models/dashboard';
import { ISavedSearch, SavedSearch } from '@/models/savedSearch';
import { IUser } from '@/models/user';
import Webhook from '@/models/webhook';
import { Api400Error } from '@/utils/errors';
import logger from '@/utils/logger';
import { alertSchema, objectIdSchema } from '@/utils/zod';

export type AlertInput = {
  id?: string;
  source?: AlertSource;
  channel: AlertChannel;
  interval: AlertInterval;
  scheduleOffsetMinutes?: number;
  scheduleStartAt?: string | null;
  thresholdType: AlertThresholdType;
  threshold: number;

  // Message template
  name?: string | null;
  message?: string | null;

  // Log alerts
  groupBy?: string;
  savedSearchId?: string;

  // Chart alerts
  dashboardId?: string;
  tileId?: string;

  // Silenced
  silenced?: {
    by?: ObjectId;
    at: Date;
    until: Date;
  };
};

const validateObjectId = (id: string | undefined, message: string) => {
  if (objectIdSchema.safeParse(id).success === false) {
    throw new Api400Error(message);
  }
};

export const validateAlertInput = async (
  teamId: ObjectId,
  alertInput: Pick<
    AlertInput,
    'source' | 'dashboardId' | 'tileId' | 'savedSearchId' | 'channel'
  >,
) => {
  if (alertInput.source === AlertSource.TILE) {
    validateObjectId(alertInput.dashboardId, 'Invalid dashboard ID');

    const dashboard = await Dashboard.findOne({
      _id: alertInput.dashboardId,
      team: teamId,
    });

    if (dashboard == null) {
      throw new Api400Error('Dashboard not found');
    }

    const tile = dashboard.tiles.find(tile => tile.id === alertInput.tileId);

    if (tile == null) {
      throw new Api400Error('Tile not found');
    }

    if (tile.config != null && isRawSqlSavedChartConfig(tile.config)) {
      if (!displayTypeSupportsRawSqlAlerts(tile.config.displayType)) {
        throw new Api400Error(
          'Alerts on Raw SQL tiles are only supported for Line, Stacked Bar, or Number display types',
        );
      }

      const { errors } = validateRawSqlForAlert(tile.config);
      if (errors.length > 0) {
        throw new Api400Error(
          `Raw SQL alert query is invalid: ${errors.join(', ')}`,
        );
      }
    }
  }

  if (alertInput.source === AlertSource.SAVED_SEARCH) {
    validateObjectId(alertInput.savedSearchId, 'Invalid saved search ID');

    const savedSearch = await SavedSearch.findOne({
      _id: alertInput.savedSearchId,
      team: teamId,
    });

    if (savedSearch == null) {
      throw new Api400Error('Saved search not found');
    }
  }

  if (alertInput.channel.type === 'webhook') {
    validateObjectId(alertInput.channel.webhookId, 'Invalid webhook ID');

    if (
      (await Webhook.findOne({
        _id: alertInput.channel.webhookId,
        team: teamId,
      })) == null
    ) {
      throw new Api400Error('Webhook not found');
    }
  }
};

const makeAlert = (alert: AlertInput, userId?: ObjectId): Partial<IAlert> => {
  // Preserve existing DB value when scheduleStartAt is omitted from updates
  // (undefined), while still allowing explicit clears via null.
  const hasScheduleStartAt = alert.scheduleStartAt !== undefined;
  // If scheduleStartAt is explicitly provided, offset-based alignment is ignored.
  // Force persisted offset to 0 so updates can't leave stale non-zero offsets.
  // If scheduleStartAt is explicitly cleared and offset is omitted, also reset
  // to 0 to avoid preserving stale values from older documents.
  const normalizedScheduleOffsetMinutes =
    hasScheduleStartAt && alert.scheduleStartAt != null
      ? 0
      : hasScheduleStartAt && alert.scheduleOffsetMinutes == null
        ? 0
        : alert.scheduleOffsetMinutes;

  return {
    channel: alert.channel,
    interval: alert.interval,
    ...(normalizedScheduleOffsetMinutes != null && {
      scheduleOffsetMinutes: normalizedScheduleOffsetMinutes,
    }),
    ...(hasScheduleStartAt && {
      scheduleStartAt:
        alert.scheduleStartAt == null ? null : new Date(alert.scheduleStartAt),
    }),
    source: alert.source,
    threshold: alert.threshold,
    thresholdType: alert.thresholdType,
    ...(userId && { createdBy: userId }),

    // Message template
    // If they're undefined/null, set it to null so we clear out the field
    // due to mongoose behavior:
    // https://mongoosejs.com/docs/migrating_to_6.html#removed-omitundefined
    name: alert.name == null ? null : alert.name,
    message: alert.message == null ? null : alert.message,

    // Log alerts
    savedSearch: alert.savedSearchId as unknown as ObjectId,
    groupBy: alert.groupBy,
    // Chart alerts
    dashboard: alert.dashboardId as unknown as ObjectId,
    tileId: alert.tileId,
  };
};

export const createAlert = async (
  teamId: ObjectId,
  alertInput: z.infer<typeof alertSchema>,
  userId: ObjectId,
) => {
  return new Alert({
    ...makeAlert(alertInput, userId),
    team: teamId,
  }).save();
};

// create an update alert function based off of the above create alert function
export const updateAlert = async (
  id: string,
  teamId: ObjectId,
  alertInput: AlertInput,
) => {
  // should consider clearing AlertHistory when updating an alert?
  return Alert.findOneAndUpdate(
    {
      _id: id,
      team: teamId,
    },
    makeAlert(alertInput),
    {
      returnDocument: 'after',
    },
  );
};

export const getAlerts = async (teamId: ObjectId) => {
  return Alert.find({ team: teamId });
};

export const getAlertById = async (
  alertId: ObjectId | string,
  teamId: ObjectId | string,
) => {
  return Alert.findOne({
    _id: alertId,
    team: teamId,
  });
};

export const getTeamDashboardAlertsByDashboardAndTile = async (
  teamId: ObjectId,
) => {
  const alerts = await Alert.find({
    source: AlertSource.TILE,
    team: teamId,
  }).populate('createdBy', 'email name');
  return groupBy(alerts, a => `${a.dashboard?.toString()}:${a.tileId}`);
};

export const getDashboardAlertsByTile = async (
  teamId: ObjectId,
  dashboardId: ObjectId | string,
) => {
  const alerts = await Alert.find({
    dashboard: dashboardId,
    source: AlertSource.TILE,
    team: teamId,
  }).populate('createdBy', 'email name');
  return groupBy(alerts, 'tileId');
};

export const createOrUpdateDashboardAlerts = async (
  dashboardId: ObjectId | string,
  teamId: ObjectId,
  alertsByTile: Record<string, AlertInput>,
  userId?: ObjectId,
) => {
  return Promise.all(
    Object.entries(alertsByTile).map(async ([tileId, alert]) => {
      const filter = {
        dashboard: dashboardId,
        tileId,
        source: AlertSource.TILE,
        team: teamId,
      };
      const oldAlert = await Alert.findOne(filter);
      const alertValues =
        oldAlert && oldAlert.createdBy
          ? makeAlert(alert)
          : makeAlert(alert, userId);

      return await Alert.findOneAndUpdate(filter, alertValues, {
        new: true,
        upsert: true,
      });
    }),
  );
};

export const deleteDashboardAlerts = async (
  dashboardId: ObjectId | string,
  teamId: ObjectId,
  tileIds?: string[],
) => {
  return Alert.deleteMany({
    dashboard: dashboardId,
    team: teamId,
    source: AlertSource.TILE,
    ...(tileIds && { tileId: { $in: tileIds } }),
  });
};

export const deleteSavedSearchAlerts = async (
  savedSearchId: string,
  teamId: string,
) => {
  return Alert.deleteMany({
    savedSearch: savedSearchId,
    team: teamId,
  });
};

export const getAlertsEnhanced = async (teamId: ObjectId) => {
  return Alert.find({ team: teamId }).populate<{
    savedSearch: ISavedSearch;
    dashboard: IDashboard;
    createdBy?: IUser;
    silenced?: IAlert['silenced'] & {
      by: IUser;
    };
  }>(['savedSearch', 'dashboard', 'createdBy', 'silenced.by']);
};

export const getAlertEnhanced = async (
  alertId: ObjectId | string,
  teamId: ObjectId,
) => {
  return Alert.findOne({ _id: alertId, team: teamId }).populate<{
    savedSearch: ISavedSearch;
    dashboard: IDashboard;
    createdBy?: IUser;
    silenced?: IAlert['silenced'] & {
      by: IUser;
    };
  }>(['savedSearch', 'dashboard', 'createdBy', 'silenced.by']);
};

export const deleteAlert = async (id: string, teamId: ObjectId) => {
  return Alert.deleteOne({
    _id: id,
    team: teamId,
  });
};

export const generateAlertSilenceToken = async (
  alertId: ObjectId | string,
  teamId: ObjectId | string,
) => {
  const secret = process.env.EXPRESS_SESSION_SECRET;

  if (!secret) {
    logger.error(
      'EXPRESS_SESSION_SECRET is not set for signing token, skipping alert silence JWT generation',
    );
    return '';
  }

  const alert = await getAlertById(alertId, teamId);
  if (alert == null) {
    throw new Error('Alert not found');
  }

  const token = sign(
    { alertId: alert._id.toString(), teamId: teamId.toString() },
    secret,
    { expiresIn: '1h' },
  );

  // Slack does not accept ids longer than 255 characters
  if (token.length > 255) {
    logger.error(
      'Alert silence JWT length is greater than 255 characters, this may cause issues with some clients.',
    );
  }

  return token;
};

export const silenceAlertByToken = async (token: string) => {
  const secret = process.env.EXPRESS_SESSION_SECRET;

  if (!secret) {
    throw new Error('EXPRESS_SESSION_SECRET is not set for verifying token');
  }

  const decoded = verify(token, secret, {
    algorithms: ['HS256'],
  }) as { alertId: string; teamId: string };

  if (!decoded?.alertId || !decoded?.teamId) {
    throw new Error('Invalid token');
  }

  const alert = await getAlertById(decoded.alertId, decoded.teamId);
  if (alert == null) {
    throw new Error('Alert not found');
  }

  alert.silenced = {
    at: new Date(),
    until: new Date(Date.now() + ms('30m')),
  };

  return alert.save();
};