@oneuptime/common 12.0.0 → 12.0.2

package/Types/Events/Recurring.ts

@@ -1,5 +1,5 @@
 import DatabaseProperty from "../Database/DatabaseProperty";
-import OneUptimeDate from "../Date";
+import OneUptimeDate, { CalendarUnit } from "../Date";
 import BadDataException from "../Exception/BadDataException";
 import { JSONArray, JSONObject, ObjectType } from "../JSON";
 import JSONFunctions from "../JSONFunctions";
@@ -109,6 +109,104 @@ export default class Recurring extends DatabaseProperty {
     return nextDate;
   }
 
+  /*
+   * The calendar unit this interval is expressed in, for the date helpers that
+   * do calendar (rather than fixed-millisecond) arithmetic.
+   */
+  public static toCalendarUnit(intervalType: EventInterval): CalendarUnit {
+    switch (intervalType) {
+      case EventInterval.Hour:
+        return "hour";
+      case EventInterval.Day:
+        return "day";
+      case EventInterval.Week:
+        return "week";
+      case EventInterval.Month:
+        return "month";
+      case EventInterval.Year:
+        return "year";
+      default:
+        throw new BadDataException("Invalid Interval Type: " + intervalType);
+    }
+  }
+
+  /**
+   * The first occurrence of `recurring` (anchored at `startDate`) strictly after
+   * `afterDate`, stepping in whole CALENDAR units in `timezone`.
+   *
+   * getNextDate() approximates a month as 30.4375 days and a year as 365.25
+   * days, which is fine for hours/days/weeks but makes a monthly recurrence
+   * walk backwards through the calendar: anchored on 1 Jul it fires on 31 Jul,
+   * then 30 Aug, and eventually skips a month entirely. This steps 1 Jul ->
+   * 1 Aug -> 1 Sep instead, and holds the local time of day across DST.
+   *
+   * A start date already after `afterDate` is returned unchanged - the first
+   * occurrence has not happened yet.
+   */
+  public static getNextDateAfter(data: {
+    startDate: Date;
+    recurring: Recurring;
+    afterDate: Date;
+    timezone?: string | undefined;
+  }): Date {
+    const startDate: Date = OneUptimeDate.fromString(data.startDate);
+    const recurring: Recurring = Recurring.fromJSON(data.recurring);
+    const unit: CalendarUnit = Recurring.toCalendarUnit(recurring.intervalType);
+
+    const intervalCount: number = Math.max(
+      1,
+      Math.floor(recurring.intervalCount.toNumber()),
+    );
+
+    if (startDate.getTime() > data.afterDate.getTime()) {
+      return startDate;
+    }
+
+    /*
+     * Jump most of the way in one step so a status page left disabled for a year
+     * does not loop 365 times, then walk the remainder. The estimate can only be
+     * off by a single interval either way (calendar units are not uniform), so
+     * the two loops below run a handful of times at most.
+     */
+    const elapsedUnits: number = OneUptimeDate.getCalendarUnitsBetween(
+      startDate,
+      data.afterDate,
+      unit,
+      data.timezone,
+    );
+
+    let intervals: number = Math.max(
+      0,
+      Math.floor(elapsedUnits / intervalCount),
+    );
+
+    type OccurrenceFunction = (intervalsToAdd: number) => Date;
+
+    const occurrence: OccurrenceFunction = (intervalsToAdd: number): Date => {
+      return OneUptimeDate.addRemoveCalendarUnits(
+        startDate,
+        unit,
+        intervalsToAdd * intervalCount,
+        data.timezone,
+      );
+    };
+
+    // Overshot - come back until we are at or before the cutoff.
+    while (
+      intervals > 0 &&
+      occurrence(intervals - 1).getTime() > data.afterDate.getTime()
+    ) {
+      intervals--;
+    }
+
+    // Undershot - advance until we are strictly after it.
+    while (occurrence(intervals).getTime() <= data.afterDate.getTime()) {
+      intervals++;
+    }
+
+    return occurrence(intervals);
+  }
+
   private data: RecurringData = Recurring.getDefaultRotationData();
 
   public get intervalType(): EventInterval {

package/Types/Runbook/RunbookStep.ts

@@ -72,6 +72,21 @@ export interface AIStepConfig {
    * Response token cap. Defaults to 4096; clamped server-side.
    */
   maxTokens?: number;
+  /*
+   * Pin this step to a specific LLM provider. Optional — when unset the step
+   * uses the project's default provider (and, failing that, the global
+   * OneUptime provider), which is what every AI step did before this field
+   * existed.
+   *
+   * The id must name a provider the project owns or a global one; the server
+   * re-checks that on every run rather than trusting the stored config, since
+   * Runbook.steps is an unvalidated JSON column. A pinned provider that no
+   * longer resolves FAILS the step instead of quietly falling back to the
+   * default: an AI step runs unattended, and silently answering on a
+   * different model than the one a responder pinned is a change nobody would
+   * see. (Interactive chat, which has a human watching, does fall back.)
+   */
+  llmProviderId?: string;
 }
 
 /*

package/Types/Runner/RunnerLiveStatus.ts

@@ -0,0 +1,114 @@
+import OneUptimeDate from "../Date";
+
+/*
+ * How recently a Runner must have heartbeated to count as online. Matches the
+ * window AIAgentService.isAgentAlive uses, and comfortably clears the Runner's
+ * 60s heartbeat interval.
+ *
+ * This lives in Types, not in RunnerService, because the dashboard has to
+ * answer the same question the server does. RunnerService imports it from
+ * here so the two cannot drift: a server that hands out work to Runners it
+ * considers alive, next to a dashboard that calls those same Runners
+ * disconnected, is worse than either answer on its own.
+ */
+export const RUNNER_ALIVE_WINDOW_IN_MINUTES: number = 5;
+
+/*
+ * What a Runner's heartbeat actually says about it right now.
+ *
+ * Deliberately NOT the same thing as the persisted RunnerConnectionStatus
+ * column. That column is written exactly twice — Disconnected when the row is
+ * created, Connected on the first heartbeat — and nothing ever writes it back,
+ * so a Runner that ran once last March still reads "connected" today. Every
+ * server-side liveness check already ignores it and compares lastAlive against
+ * the window above; this enum lets the dashboard tell the user the same truth.
+ */
+export enum RunnerLiveStatus {
+  /* Heartbeated within the window: it is polling for work right now. */
+  Connected = "connected",
+
+  /*
+   * Heartbeated at some point, but not recently enough. The container is
+   * stopped, wedged, or cannot reach OneUptime.
+   */
+  Disconnected = "disconnected",
+
+  /*
+   * Never heartbeated at all. The row exists because someone created it in the
+   * dashboard, but the Docker command has not been run yet. This is a setup
+   * step the user still owes us, not a failure, and the UI must not dress it up
+   * as one.
+   */
+  NeverConnected = "never-connected",
+}
+
+/*
+ * lastAlive arrives as a Date from a hydrated model and as an ISO string from
+ * a raw API payload, so both are accepted. Anything falsy — null from Postgres,
+ * undefined from a select that never asked for the column — means "no heartbeat
+ * has ever been recorded".
+ */
+export type GetRunnerLiveStatusFunction = (
+  lastAlive: Date | string | null | undefined,
+) => RunnerLiveStatus;
+
+export const getRunnerLiveStatus: GetRunnerLiveStatusFunction = (
+  lastAlive: Date | string | null | undefined,
+): RunnerLiveStatus => {
+  if (!lastAlive) {
+    return RunnerLiveStatus.NeverConnected;
+  }
+
+  const lastAliveDate: Date = OneUptimeDate.fromString(lastAlive);
+
+  /*
+   * An unparseable value is not evidence of life. Returning Disconnected keeps
+   * a malformed timestamp from being reported as a healthy Runner.
+   */
+  if (isNaN(lastAliveDate.getTime())) {
+    return RunnerLiveStatus.Disconnected;
+  }
+
+  const windowStart: Date = OneUptimeDate.getSomeMinutesAgo(
+    RUNNER_ALIVE_WINDOW_IN_MINUTES,
+  );
+
+  if (OneUptimeDate.isAfter(lastAliveDate, windowStart)) {
+    return RunnerLiveStatus.Connected;
+  }
+
+  return RunnerLiveStatus.Disconnected;
+};
+
+/*
+ * The English label for each state, which is also its i18next lookup key.
+ *
+ * "Connected" and "Disconnected" already had translations in all sixteen
+ * Dashboard locale files before any of this — the probe pages have used them
+ * for years — so routing every Runner status label through these three
+ * constants is what lets the new state reuse them instead of inventing a
+ * parallel set that would have to be translated again.
+ *
+ * It lives here rather than in the component because two very different
+ * surfaces need the same words: the status bubble, and the plain-string
+ * option label in the runbook step editor's Runner picker.
+ */
+export type GetRunnerLiveStatusLabelFunction = (
+  status: RunnerLiveStatus,
+) => string;
+
+export const getRunnerLiveStatusLabel: GetRunnerLiveStatusLabelFunction = (
+  status: RunnerLiveStatus,
+): string => {
+  if (status === RunnerLiveStatus.Connected) {
+    return "Connected";
+  }
+
+  if (status === RunnerLiveStatus.NeverConnected) {
+    return "Never connected";
+  }
+
+  return "Disconnected";
+};
+
+export default RunnerLiveStatus;

package/Types/StatusPage/StatusPageReport.ts

@@ -85,6 +85,17 @@ export interface StatusPageReportRow {
 
 export interface StatusPageReport {
   reportDates: string; // start date and end date in string. e.g. "01 July 2021 - 14 July 2021"
+  /*
+   * How a sentence refers to the period this report covers - "the last 30
+   * days", "July 2026", "the week of Jul 27, 2026". `reportDates` is the raw
+   * range; this is the phrase that goes after "your status summary for ...".
+   */
+  reportPeriodName: string;
+  // The two ends of the window on their own, for templates that lay them out.
+  reportStartDate: string;
+  reportEndDate: string;
+  // The IANA zone every date above was resolved in, e.g. "America/New_York".
+  reportTimezone: string;
   totalResources: number;
   totalIncidents: number;
   averageUptimePercent: string;

package/Types/StatusPage/StatusPageReportPeriodType.ts

@@ -0,0 +1,21 @@
+/*
+ * What stretch of time a scheduled status page report covers.
+ *
+ * The report used to only ever cover "the last N days counted back from the
+ * moment the email went out", which can never line up with a calendar month -
+ * a monthly report sent on 1 Aug covered 2 Jul - 1 Aug rather than the July
+ * everyone reading it expects, and consecutive reports silently overlapped or
+ * left gaps whenever the day count did not match the send frequency.
+ */
+enum StatusPageReportPeriodType {
+  // The window ends when the email is sent and runs back `reportDataInDays`.
+  Rolling = "Rolling",
+  /*
+   * The last whole calendar period before the email is sent, sized by the send
+   * frequency: a report sent monthly covers 1 Jul 00:00 - 31 Jul 23:59:59.999
+   * in the status page's report timezone.
+   */
+  PreviousCalendarPeriod = "Previous Calendar Period",
+}
+
+export default StatusPageReportPeriodType;

package/UI/Components/Detail/Detail.tsx

@@ -178,6 +178,126 @@ const Detail: DetailFunction = <T extends GenericObject>(
     );
   };
 
+  /*
+   * Relation columns arrive as whole model instances. React throws (and takes
+   * the entire page down with it) when handed one as a child, so every object
+   * that reaches the renderer is reduced to a label with these keys, in order.
+   */
+  const entityLabelKeys: Array<string> = [
+    "name",
+    "title",
+    "label",
+    "email",
+    "slug",
+    "value",
+  ];
+
+  type GetEntityLabelFunction = (entity: unknown) => string;
+
+  const getEntityLabel: GetEntityLabelFunction = (entity: unknown): string => {
+    if (entity === null || entity === undefined) {
+      return "";
+    }
+
+    if (entity instanceof DatabaseProperty) {
+      return entity.toString();
+    }
+
+    if (typeof entity !== "object") {
+      return String(entity);
+    }
+
+    for (const key of entityLabelKeys) {
+      const value: unknown = (entity as Dictionary<unknown>)[key];
+
+      if (value === null || value === undefined || value === "") {
+        continue;
+      }
+
+      if (value instanceof DatabaseProperty) {
+        return value.toString();
+      }
+
+      if (typeof value !== "object") {
+        return String(value);
+      }
+    }
+
+    return "";
+  };
+
+  type GetEntityColorFunction = (entity: unknown) => Color | string | undefined;
+
+  const getEntityColor: GetEntityColorFunction = (
+    entity: unknown,
+  ): Color | string | undefined => {
+    if (!entity || typeof entity !== "object") {
+      return undefined;
+    }
+
+    const color: unknown = (entity as Dictionary<unknown>)["color"];
+
+    if (color instanceof Color || typeof color === "string") {
+      return color;
+    }
+
+    return undefined;
+  };
+
+  type GetEntityViewerFunction = (entity: unknown) => ReactElement | string;
+
+  const getEntityViewer: GetEntityViewerFunction = (
+    entity: unknown,
+  ): ReactElement | string => {
+    const label: string = getEntityLabel(entity);
+
+    if (!label) {
+      // Fall through to the placeholder the field already declares.
+      return "";
+    }
+
+    return <DropdownValueBadge label={label} color={getEntityColor(entity)} />;
+  };
+
+  type GetEntityArrayViewerFunction = (
+    entities: Array<unknown>,
+  ) => ReactElement | string;
+
+  const getEntityArrayViewer: GetEntityArrayViewerFunction = (
+    entities: Array<unknown>,
+  ): ReactElement | string => {
+    const labelled: Array<{ label: string; entity: unknown }> = entities
+      .map((entity: unknown) => {
+        return { label: getEntityLabel(entity), entity: entity };
+      })
+      .filter((item: { label: string; entity: unknown }) => {
+        return Boolean(item.label);
+      });
+
+    if (labelled.length === 0) {
+      return "";
+    }
+
+    return (
+      <div className="flex flex-wrap gap-1.5">
+        {labelled.map(
+          (
+            item: { label: string; entity: unknown },
+            index: number,
+          ): ReactElement => {
+            return (
+              <DropdownValueBadge
+                key={`${item.label}-${index}`}
+                label={item.label}
+                color={getEntityColor(item.entity)}
+              />
+            );
+          },
+        )}
+      </div>
+    );
+  };
+
   type GetDictionaryOfStringsViewerFunction = (
     data: Dictionary<string>,
   ) => ReactElement;
@@ -486,6 +606,16 @@ const Detail: DetailFunction = <T extends GenericObject>(
       );
     }
 
+    if (data && field.fieldType === FieldType.Entity) {
+      data = getEntityViewer(data);
+    }
+
+    if (data && field.fieldType === FieldType.EntityArray) {
+      data = getEntityArrayViewer(
+        Array.isArray(data) ? (data as Array<unknown>) : [data],
+      );
+    }
+
     if (data && field.fieldType === FieldType.HiddenText) {
       data = (
         <HiddenText
@@ -608,6 +738,31 @@ const Detail: DetailFunction = <T extends GenericObject>(
       data = data.toString();
     }
 
+    /*
+     * Last resort. Anything still an object here is something no field type
+     * claimed - usually a relation column declared without FieldType.Entity.
+     * Rendering it would throw "Objects are not valid as a React child" and
+     * blank the whole page, so label it instead and log the misconfiguration.
+     */
+    if (data && typeof data === "object" && !React.isValidElement(data)) {
+      Logger.error(
+        "Detail: no field type renders the value of '" +
+          fieldKeyStr +
+          "'. Set fieldType (FieldType.Entity for relations) or getElement on the field.",
+      );
+
+      data = Array.isArray(data)
+        ? (data as Array<unknown>)
+            .map((entity: unknown) => {
+              return getEntityLabel(entity);
+            })
+            .filter((label: string) => {
+              return Boolean(label);
+            })
+            .join(", ")
+        : getEntityLabel(data);
+    }
+
     // Determine style-based classes
     const styleType: DetailStyle = props.style || DetailStyle.Default;
     const isCardStyle: boolean = styleType === DetailStyle.Card;

package/UI/Components/ModelTable/CustomFieldColumns.tsx

@@ -5,6 +5,7 @@ import DropdownValueBadge from "../Dropdown/DropdownValueBadge";
 import AnalyticsBaseModel from "../../../Models/AnalyticsModels/AnalyticsBaseModel/AnalyticsBaseModel";
 import BaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
 import CustomFieldType from "../../../Types/CustomField/CustomFieldType";
+import { CustomFieldDefinition } from "../../../Types/CustomField/CustomFieldDefinition";
 import {
   CustomFieldDropdownOption,
   parseCustomFieldDropdownOptions,
@@ -45,12 +46,7 @@ import React, { ReactElement } from "react";
  * fall-through text branch understands a dotted key.
  */
 
-export interface CustomFieldDefinition {
-  name: string;
-  description?: string | undefined;
-  customFieldType?: CustomFieldType | undefined;
-  dropdownOptions?: string | undefined;
-}
+export type { CustomFieldDefinition } from "../../../Types/CustomField/CustomFieldDefinition";
 
 export const CustomFieldsColumnKey: string = "customFields";
 

package/UI/Components/ModelTable/useCustomFieldColumns.ts

@@ -55,18 +55,37 @@ const useCustomFieldColumns: UseCustomFieldColumnsFunction = <
   const [definitions, setDefinitions] = useState<Array<CustomFieldDefinition>>(
     [],
   );
-  const [isLoading, setIsLoading] = useState<boolean>(false);
-  const [error, setError] = useState<string>("");
 
   const projectId: ObjectID | null =
     data.projectId ?? ProjectUtil.getCurrentProjectId();
 
+  /*
+   * Starts true whenever a request is actually going to happen, rather than
+   * false-until-the-effect-runs.
+   *
+   * Columns did not care — they only ever appear — but a caller that has to
+   * distinguish "no custom fields" from "not yet" does. The facet bar is one:
+   * on the first render it must know that a chip restored from a shared link
+   * may still be on its way, or it drops the link's filter before the request
+   * has even been sent.
+   */
+  const [isLoading, setIsLoading] = useState<boolean>(
+    Boolean(data.customFieldsModelType && projectId),
+  );
+  const [error, setError] = useState<string>("");
+
   const projectIdString: string = projectId?.toString() || "";
   const modelName: string = customFieldsModelType?.name || "";
 
   useEffect(() => {
     if (!customFieldsModelType || !projectId) {
       setDefinitions([]);
+      /*
+       * Nothing to wait for. Said explicitly because the initial state is now
+       * "loading" whenever a request is expected, and a model type that goes
+       * away between renders would otherwise leave it stuck there.
+       */
+      setIsLoading(false);
       return;
     }