Skip to content

Open-source status page, incident response and uptime monitoring

5.1 KB
Raw Blame
import type { StatusReportStatus } from "@openstatus/db/src/schema";
import {
  type PageComponentImpact,
  pageComponentImpact,
} from "@openstatus/db/src/schema/page_components/constants";
import { Settings, Delete } from "@openstatus/icons";

import type { StatusVariant } from "@/components/common/status-dot";
import type { FormValues as StatusReportUpdateFormValues } from "@/components/forms/status-report-update/form";
import { toEntityId } from "@/data/entity-refs.client";

export const impactConfig = {
  operational: {
    label: "Operational",
    variant: "success",
  },
  degraded_performance: {
    label: "Degraded performance",
    variant: "warning",
  },
  partial_outage: {
    label: "Partial outage",
    variant: "warning",
  },
  major_outage: {
    label: "Major outage",
    variant: "destructive",
  },
} as const satisfies Record<
  PageComponentImpact,
  { label: string; variant: StatusVariant }
>;

export type ComponentImpact = {
  pageComponentId: number;
  impact: PageComponentImpact;
};

export function isPageComponentImpact(
  value: unknown,
): value is PageComponentImpact {
  return (
    typeof value === "string" &&
    (pageComponentImpact as readonly string[]).includes(value)
  );
}

export function isComponentImpactList(
  value: unknown,
): value is ComponentImpact[] {
  return (
    Array.isArray(value) &&
    value.every(
      (item: unknown) =>
        typeof item === "object" &&
        item !== null &&
        "pageComponentId" in item &&
        "impact" in item &&
        typeof item.pageComponentId === "number" &&
        toEntityId(item.pageComponentId) !== undefined &&
        isPageComponentImpact(item.impact),
    )
  );
}

/** Set equality regardless of order — used to skip no-op impact writes. */
export function impactsEqual(
  a: { pageComponentId: number; impact: string }[],
  b: { pageComponentId: number; impact: string }[],
) {
  const key = (list: { pageComponentId: number; impact: string }[]) =>
    [...list]
      .sort((x, y) => x.pageComponentId - y.pageComponentId)
      .map((x) => `${x.pageComponentId}:${x.impact}`)
      .join(",");
  return key(a) === key(b);
}

// legacy report (created before impact tracking): no impact rows
export const untriagedImpact = {
  label: "Untriaged",
  variant: "default",
} as const satisfies { label: string; variant: StatusVariant };

/** Label + dot variant for an impact; nullish reads as untriaged. */
export function impactDisplay(impact: PageComponentImpact | null | undefined) {
  return impact ? impactConfig[impact] : untriagedImpact;
}

export const actions = [
  {
    id: "edit",
    label: "Settings",
    icon: Settings,
    variant: "default" as const,
  },
  {
    id: "delete",
    label: "Delete",
    icon: Delete,
    variant: "destructive" as const,
  },
] as const;

export type StatusReportUpdateAction = (typeof actions)[number];

export const getActions = (
  props: Partial<
    Record<StatusReportUpdateAction["id"], () => Promise<void> | void>
  >,
): (StatusReportUpdateAction & { onClick?: () => Promise<void> | void })[] => {
  return actions.map((action) => ({
    ...action,
    onClick: props[action.id as keyof typeof props],
  }));
};

export const colors = {
  resolved:
    "text-success/80 data-[state=selected]:bg-success/10 data-[state=selected]:text-success",
  investigating:
    "text-destructive/80 data-[state=selected]:bg-destructive/10 data-[state=selected]:text-destructive",
  monitoring:
    "text-info/80 data-[state=selected]:bg-info/10 data-[state=selected]:text-info",
  identified:
    "text-warning/80 data-[state=selected]:bg-warning/10 data-[state=selected]:text-warning",
} as const satisfies Record<StatusReportStatus, string>;

export const statusVariants = {
  resolved: "success",
  investigating: "destructive",
  monitoring: "info",
  identified: "warning",
} as const satisfies Record<StatusReportStatus, StatusVariant>;

/**
 * Get the next status in the progression:
 * investigating → identified → monitoring → resolved
 *
 * @param currentStatus - The current status
 * @returns The next status in the progression, or 'resolved' if already at the end, or 'investigating' for invalid statuses
 */
export function getNextStatus(currentStatus: string): StatusReportStatus {
  const statusProgression: Record<StatusReportStatus, StatusReportStatus> = {
    investigating: "identified",
    identified: "monitoring",
    monitoring: "resolved",
    resolved: "resolved",
  };

  return (
    statusProgression[currentStatus as StatusReportStatus] ?? "investigating"
  );
}

// a legacy report stays legacy unless the operator actively sets a
// non-operational impact — never silently flip it green
export function toCreateStatusReportUpdateInput({
  statusReportId,
  values,
  reportHasImpacts,
}: {
  statusReportId: number;
  values: StatusReportUpdateFormValues;
  reportHasImpacts: boolean;
}) {
  const sendImpacts =
    reportHasImpacts ||
    values.componentImpacts?.some((ci) => ci.impact !== "operational");
  return {
    statusReportId,
    message: values.message,
    status: values.status,
    componentImpacts: sendImpacts ? values.componentImpacts : undefined,
    date: values.date,
    notifySubscribers: values.notifySubscribers,
  };
}