@oneuptime/common 13.0.1 → 13.0.3

package/UI/Components/RuleCriteria/RuleCriteriaModelForm.tsx

@@ -0,0 +1,209 @@
+import RuleBaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/RuleBaseModel";
+import RelationOnlyRuleBaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/RelationOnlyRuleBaseModel";
+import BaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import TableColumnType from "../../../Types/Database/TableColumnType";
+import RuleCriteria, {
+  RULE_CRITERIA_LEGACY_NEVER_MATCH_PATTERN,
+} from "../../../Types/Rules/RuleCriteria";
+import { getRuleCriteriaValidationError } from "../../../Utils/Rules/RuleCriteriaMatcher";
+import SelectFormFields from "../../Types/SelectEntityField";
+import React, { ReactElement } from "react";
+import Field, { CustomElementProps } from "../Forms/Types/Field";
+import Fields from "../Forms/Types/Fields";
+import FormFieldSchemaType from "../Forms/Types/FormFieldSchemaType";
+import FormValues from "../Forms/Types/FormValues";
+import RuleCriteriaBuilder, {
+  getRuleCriteriaFieldName,
+} from "./RuleCriteriaBuilder";
+
+export const MATCH_CRITERIA_STEP_ID: string = "match-criteria";
+export const RULE_CRITERIA_FIELD_NAME: string = "criteria";
+
+export function getLegacyRuleCriteriaFields<TEntity>(
+  fields: Array<Field<TEntity>>,
+): Array<Field<TEntity>> {
+  return fields.filter((field: Field<TEntity>): boolean => {
+    return (
+      field.stepId === MATCH_CRITERIA_STEP_ID &&
+      getRuleCriteriaFieldName(field) !== RULE_CRITERIA_FIELD_NAME
+    );
+  });
+}
+
+export function shouldUseRuleCriteriaBuilder<TEntity>(
+  model: BaseModel,
+  fields: Array<Field<TEntity>>,
+): model is RuleBaseModel {
+  return (
+    model instanceof RuleBaseModel &&
+    getLegacyRuleCriteriaFields(fields).length > 0
+  );
+}
+
+export function addRuleCriteriaToSelect<TEntity>(data: {
+  model: BaseModel;
+  fields: Array<Field<TEntity>>;
+  select: Record<string, unknown>;
+}): Record<string, unknown> {
+  if (!shouldUseRuleCriteriaBuilder(data.model, data.fields)) {
+    return data.select;
+  }
+
+  return {
+    ...data.select,
+    [RULE_CRITERIA_FIELD_NAME]: true,
+  };
+}
+
+/**
+ * Keep requests fail-closed when a new dashboard is briefly routed to an old
+ * API pod during a rolling deployment. The old API drops the unknown criteria
+ * column, but it still understands these legacy fields.
+ */
+export function applyRuleCriteriaLegacySafetyShadow<
+  TEntity extends BaseModel,
+>(data: {
+  model: BaseModel;
+  fields: Fields<TEntity>;
+  values: Record<string, unknown>;
+}): void {
+  if (!shouldUseRuleCriteriaBuilder(data.model, data.fields)) {
+    return;
+  }
+
+  const criteria: unknown = data.values[RULE_CRITERIA_FIELD_NAME];
+
+  if (
+    typeof criteria !== "object" ||
+    criteria === null ||
+    Array.isArray(criteria)
+  ) {
+    return;
+  }
+
+  const relationOnlyRule: boolean =
+    data.model instanceof RelationOnlyRuleBaseModel;
+  let safetyPatternField: string | undefined;
+
+  for (const field of getLegacyRuleCriteriaFields(data.fields)) {
+    const fieldName: string | null = getRuleCriteriaFieldName(field);
+
+    if (!fieldName) {
+      continue;
+    }
+
+    const fieldType: TableColumnType | undefined =
+      data.model.getTableColumnMetadata(fieldName)?.type;
+    data.values[fieldName] =
+      fieldType === TableColumnType.EntityArray ? [] : null;
+
+    if (
+      !relationOnlyRule &&
+      !safetyPatternField &&
+      fieldType !== TableColumnType.EntityArray &&
+      fieldName.match(/(pattern|regex)/i) !== null
+    ) {
+      safetyPatternField = fieldName;
+    }
+  }
+
+  if (relationOnlyRule) {
+    const logicalEnabled: boolean =
+      typeof data.values["isEnabled"] === "boolean"
+        ? (data.values["isEnabled"] as boolean)
+        : true;
+
+    data.values[RULE_CRITERIA_FIELD_NAME] = {
+      ...(criteria as RuleCriteria),
+      isEnabled: logicalEnabled,
+    };
+    data.values["isEnabled"] = false;
+    return;
+  }
+
+  if (!safetyPatternField) {
+    throw new Error(
+      `A legacy safety pattern is required for ${data.model.tableName}.`,
+    );
+  }
+
+  data.values[safetyPatternField] = RULE_CRITERIA_LEGACY_NEVER_MATCH_PATTERN;
+}
+
+export function replaceLegacyRuleCriteriaFields<TEntity extends BaseModel>(
+  model: BaseModel,
+  fields: Fields<TEntity>,
+): Fields<TEntity> {
+  if (!shouldUseRuleCriteriaBuilder(model, fields)) {
+    return fields;
+  }
+
+  const legacyFields: Array<Field<TEntity>> =
+    getLegacyRuleCriteriaFields(fields);
+  const fieldsToReplace: Set<Field<TEntity>> = new Set<Field<TEntity>>([
+    ...legacyFields,
+    ...fields.filter((field: Field<TEntity>): boolean => {
+      return getRuleCriteriaFieldName(field) === RULE_CRITERIA_FIELD_NAME;
+    }),
+  ]);
+  const firstFieldIndex: number = fields.findIndex(
+    (field: Field<TEntity>): boolean => {
+      return fieldsToReplace.has(field);
+    },
+  );
+
+  const criteriaField: Field<TEntity> = {
+    field: {
+      [RULE_CRITERIA_FIELD_NAME]: true,
+    } as SelectFormFields<TEntity>,
+    title: "Conditions",
+    description:
+      "Add one or more conditions and choose whether every condition or any condition must match.",
+    stepId: MATCH_CRITERIA_STEP_ID,
+    fieldType: FormFieldSchemaType.CustomComponent,
+    required: false,
+    spanFullRow: true,
+    dataTestId: "rule-criteria-field",
+    customValidation: (values: FormValues<TEntity>): string | null => {
+      const criteria: unknown = (values as { criteria?: unknown }).criteria;
+
+      if (criteria === undefined || criteria === null) {
+        return null;
+      }
+
+      return getRuleCriteriaValidationError(criteria);
+    },
+    getCustomElement: (
+      values: FormValues<TEntity>,
+      customElementProps: CustomElementProps,
+    ): ReactElement => {
+      return (
+        <RuleCriteriaBuilder
+          fields={legacyFields}
+          legacyValues={values as unknown as Record<string, unknown>}
+          value={(values as { criteria?: RuleCriteria }).criteria}
+          error={customElementProps.error}
+          onChange={(criteria: RuleCriteria): void => {
+            customElementProps.onChange?.(criteria);
+          }}
+        />
+      );
+    },
+  };
+
+  const result: Fields<TEntity> = [];
+
+  for (let index: number = 0; index < fields.length; index++) {
+    if (index === firstFieldIndex) {
+      result.push(criteriaField);
+    }
+
+    const field: Field<TEntity> = fields[index]!;
+
+    if (!fieldsToReplace.has(field)) {
+      result.push(field);
+    }
+  }
+
+  return result;
+}

package/UI/Components/RuleCriteria/RuleCriteriaModelTable.tsx

@@ -0,0 +1,205 @@
+import BaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import RuleBaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/RuleBaseModel";
+import Select from "../../../Types/BaseDatabase/Select";
+import React from "react";
+import type { ModelField } from "../Forms/ModelForm";
+import type Filter from "../ModelFilter/Filter";
+import type Column from "../ModelTable/Column";
+import type Columns from "../ModelTable/Columns";
+import FieldType from "../Types/FieldType";
+import { getRuleCriteriaFieldName } from "./RuleCriteriaBuilder";
+import {
+  getLegacyRuleCriteriaFields,
+  RULE_CRITERIA_FIELD_NAME,
+} from "./RuleCriteriaModelForm";
+import RuleCriteriaSummary, {
+  getRuleCriteriaSummaryText,
+} from "./RuleCriteriaSummary";
+
+export interface RuleCriteriaTableConfiguration<TEntity extends BaseModel> {
+  columns: Columns<TEntity>;
+  filters: Array<Filter<TEntity>>;
+  selectMoreFields?: Select<TEntity> | undefined;
+  helpContent?: RuleCriteriaTableHelpContent | undefined;
+}
+
+export interface RuleCriteriaTableHelpContent {
+  title: string;
+  description?: string | undefined;
+  markdown: string;
+}
+
+export const RULE_CRITERIA_HELP_SECTION_BODY: string = `Add one or more conditions, then choose how they are combined:
+
+- **Match all (AND)** — every condition must match.
+- **Match any (OR)** — at least one condition must match.
+
+Choose an operator for each condition. Only operators supported by the selected field are shown; these can include:
+
+- **Equality** — Equals or Does not equal.
+- **Text matching** — Contains, Does not contain, Starts with, or Ends with.
+- **Pattern matching** — Matches pattern or Does not match pattern. Patterns accept a regular expression or a \`*\` wildcard pattern.
+- **Multi-select matching** — Has any of, Has all of, or Has none of the selected values.`;
+
+const RULE_CRITERIA_HELP_HEADING: RegExp =
+  /^(#{1,6})[\t ]+Match Criteria(?:[\t ]+\(Filtering\))?[\t ]*$/;
+const MARKDOWN_HEADING: RegExp = /^(#{1,6})[\t ]+/;
+
+/**
+ * Replace only the body of a rule help document's match-criteria section.
+ * Other sections are intentionally retained because they describe the action
+ * performed by that particular rule type.
+ */
+export function replaceRuleCriteriaHelpMarkdown(markdown: string): string {
+  const lines: Array<string> = markdown.split("\n");
+  const result: Array<string> = [];
+  let sectionWasReplaced: boolean = false;
+
+  for (let index: number = 0; index < lines.length; index++) {
+    const line: string = lines[index]!;
+    const targetHeadingMatch: RegExpMatchArray | null = line.match(
+      RULE_CRITERIA_HELP_HEADING,
+    );
+
+    if (!targetHeadingMatch) {
+      result.push(line);
+      continue;
+    }
+
+    sectionWasReplaced = true;
+    const headingLevel: number = targetHeadingMatch[1]!.length;
+
+    result.push(line, "", RULE_CRITERIA_HELP_SECTION_BODY, "");
+
+    while (index + 1 < lines.length) {
+      const nextLine: string = lines[index + 1]!;
+      const nextHeadingMatch: RegExpMatchArray | null =
+        nextLine.match(MARKDOWN_HEADING);
+
+      if (nextHeadingMatch && nextHeadingMatch[1]!.length <= headingLevel) {
+        break;
+      }
+
+      index++;
+    }
+  }
+
+  return sectionWasReplaced ? result.join("\n") : markdown;
+}
+
+function replaceRuleCriteriaHelpContent(
+  helpContent: RuleCriteriaTableHelpContent | undefined,
+): RuleCriteriaTableHelpContent | undefined {
+  if (!helpContent) {
+    return undefined;
+  }
+
+  const markdown: string = replaceRuleCriteriaHelpMarkdown(
+    helpContent.markdown,
+  );
+
+  if (markdown === helpContent.markdown) {
+    return helpContent;
+  }
+
+  return {
+    ...helpContent,
+    markdown,
+  };
+}
+
+function getPrimaryFieldName(value: {
+  field?: Record<string, unknown> | undefined;
+}): string | null {
+  return Object.keys(value.field || {})[0] || null;
+}
+
+export function getRuleCriteriaTableConfiguration<
+  TEntity extends BaseModel,
+>(data: {
+  model: TEntity;
+  formFields?: Array<ModelField<TEntity>> | undefined;
+  columns: Columns<TEntity>;
+  filters: Array<Filter<TEntity>>;
+  selectMoreFields?: Select<TEntity> | undefined;
+  helpContent?: RuleCriteriaTableHelpContent | undefined;
+}): RuleCriteriaTableConfiguration<TEntity> {
+  const legacyFields: Array<ModelField<TEntity>> = data.formFields
+    ? getLegacyRuleCriteriaFields(data.formFields)
+    : [];
+
+  if (!(data.model instanceof RuleBaseModel) || legacyFields.length === 0) {
+    return {
+      columns: data.columns,
+      filters: data.filters,
+      selectMoreFields: data.selectMoreFields,
+      helpContent: data.helpContent,
+    };
+  }
+
+  const legacyFieldNames: Set<string> = new Set<string>(
+    legacyFields
+      .map((field: ModelField<TEntity>): string | null => {
+        return getRuleCriteriaFieldName(field);
+      })
+      .filter((fieldName: string | null): fieldName is string => {
+        return Boolean(fieldName);
+      }),
+  );
+  const retainedColumns: Columns<TEntity> = [];
+  let summaryColumnIndex: number | null = null;
+
+  for (const column of data.columns) {
+    const fieldName: string | null = getPrimaryFieldName(column);
+
+    if (fieldName && legacyFieldNames.has(fieldName)) {
+      summaryColumnIndex ??= retainedColumns.length;
+      continue;
+    }
+
+    retainedColumns.push(column);
+  }
+
+  const summaryColumn: Column<TEntity> = {
+    id: "rule-criteria",
+    field: { [RULE_CRITERIA_FIELD_NAME]: true } as Column<TEntity>["field"],
+    title: "Match Criteria",
+    type: FieldType.Element,
+    disableSort: true,
+    wrapContent: true,
+    getElement: (item: TEntity) => {
+      return <RuleCriteriaSummary fields={legacyFields} item={item} />;
+    },
+    getExportValue: (item: TEntity): string => {
+      return getRuleCriteriaSummaryText({
+        fields: legacyFields,
+        item: item,
+      });
+    },
+  };
+  const insertionIndex: number =
+    summaryColumnIndex ?? Math.min(1, retainedColumns.length);
+
+  retainedColumns.splice(insertionIndex, 0, summaryColumn);
+
+  const selectMoreFields: Record<string, unknown> = {
+    ...((data.selectMoreFields || {}) as Record<string, unknown>),
+    [RULE_CRITERIA_FIELD_NAME]: true,
+  };
+
+  for (const field of legacyFields) {
+    Object.assign(selectMoreFields, field.field || {});
+  }
+
+  return {
+    columns: retainedColumns,
+    filters: data.filters.filter((filter: Filter<TEntity>): boolean => {
+      const fieldName: string | null = getPrimaryFieldName(filter);
+      return !fieldName || !legacyFieldNames.has(fieldName);
+    }),
+    selectMoreFields: selectMoreFields as Select<TEntity>,
+    helpContent: replaceRuleCriteriaHelpContent(data.helpContent),
+  };
+}
+
+export default getRuleCriteriaTableConfiguration;

package/UI/Components/RuleCriteria/RuleCriteriaSummary.tsx

@@ -0,0 +1,123 @@
+import BaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import FilterCondition from "../../../Types/Filter/FilterCondition";
+import RuleCriteria, {
+  RuleCriteriaFilter,
+} from "../../../Types/Rules/RuleCriteria";
+import { isValidRuleCriteria } from "../../../Utils/Rules/RuleCriteriaMatcher";
+import React, { ReactElement } from "react";
+import Field from "../Forms/Types/Field";
+import {
+  convertLegacyValuesToRuleCriteria,
+  getRuleCriteriaFieldName,
+  RULE_CRITERIA_OPERATOR_LABELS,
+} from "./RuleCriteriaBuilder";
+
+export interface RuleCriteriaSummaryData<TEntity> {
+  fields: Array<Field<TEntity>>;
+  item: TEntity;
+}
+
+function titleFromFieldName(fieldName: string): string {
+  return fieldName
+    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+    .replace(/[_-]+/g, " ")
+    .replace(/^./, (character: string): string => {
+      return character.toUpperCase();
+    });
+}
+
+function getFieldTitle<TEntity>(
+  fields: Array<Field<TEntity>>,
+  fieldName: string,
+): string {
+  const field: Field<TEntity> | undefined = fields.find(
+    (candidate: Field<TEntity>): boolean => {
+      return getRuleCriteriaFieldName(candidate) === fieldName;
+    },
+  );
+
+  return field?.title || titleFromFieldName(fieldName);
+}
+
+function formatValue(filter: RuleCriteriaFilter): string {
+  if (Array.isArray(filter.value)) {
+    return `${filter.value.length} selected ${
+      filter.value.length === 1 ? "value" : "values"
+    }`;
+  }
+
+  if (typeof filter.value === "boolean") {
+    return filter.value ? "true" : "false";
+  }
+
+  return `“${String(filter.value)}”`;
+}
+
+function getCriteria<TEntity>(
+  data: RuleCriteriaSummaryData<TEntity>,
+): RuleCriteria | null {
+  const item: Record<string, unknown> = data.item as unknown as Record<
+    string,
+    unknown
+  >;
+  const configuredCriteria: unknown = item["criteria"];
+
+  if (configuredCriteria !== undefined && configuredCriteria !== null) {
+    return isValidRuleCriteria(configuredCriteria) ? configuredCriteria : null;
+  }
+
+  return convertLegacyValuesToRuleCriteria({
+    fields: data.fields,
+    values: item,
+  });
+}
+
+export function getRuleCriteriaSummaryText<TEntity>(
+  data: RuleCriteriaSummaryData<TEntity>,
+): string {
+  const item: Record<string, unknown> = data.item as unknown as Record<
+    string,
+    unknown
+  >;
+  const configuredCriteria: unknown = item["criteria"];
+  const criteria: RuleCriteria | null = getCriteria(data);
+
+  if (!criteria) {
+    return configuredCriteria !== undefined && configuredCriteria !== null
+      ? "Invalid match criteria"
+      : "Matches all resources";
+  }
+
+  if (criteria.filters.length === 0) {
+    return "Matches all resources";
+  }
+
+  const connector: string =
+    criteria.filterCondition === FilterCondition.All ? "all" : "any";
+  const filters: Array<string> = criteria.filters.map(
+    (filter: RuleCriteriaFilter): string => {
+      return `${getFieldTitle(data.fields, filter.field)} ${RULE_CRITERIA_OPERATOR_LABELS[
+        filter.operator
+      ].toLocaleLowerCase()} ${formatValue(filter)}`;
+    },
+  );
+
+  return `Match ${connector}: ${filters.join("; ")}`;
+}
+
+const RuleCriteriaSummary: <TEntity extends BaseModel>(
+  props: RuleCriteriaSummaryData<TEntity>,
+) => ReactElement = <TEntity extends BaseModel>(
+  props: RuleCriteriaSummaryData<TEntity>,
+): ReactElement => {
+  const { fields, item } = props;
+  const summary: string = getRuleCriteriaSummaryText({ fields, item });
+
+  return (
+    <span className="text-sm text-gray-700" title={summary}>
+      {summary}
+    </span>
+  );
+};
+
+export default RuleCriteriaSummary;

package/UI/Components/Table/Table.tsx

@@ -28,6 +28,8 @@ export interface BulkActionProps<T extends GenericObject> {
 
 export interface ComponentProps<T extends GenericObject> {
   data: Array<T>;
+  /** Optional row attributes and navigation, shared by desktop and mobile rows. */
+  getRowProps?: ((item: T) => React.HTMLAttributes<HTMLElement>) | undefined;
   id: string;
   columns: Columns<T>;
   className?: string;
@@ -280,6 +282,7 @@ const Table: TableFunction = <T extends GenericObject>(
       <TableBody
         id={`${props.id}-body`}
         data={props.data}
+        getRowProps={props.getRowProps}
         columns={props.columns}
         actionButtons={props.actionButtons}
         enableDragAndDrop={props.enableDragAndDrop}

package/UI/Components/Table/TableBody.tsx

@@ -7,6 +7,7 @@ import { Droppable, DroppableProvided } from "react-beautiful-dnd";
 
 export interface ComponentProps<T extends GenericObject> {
   data: Array<T>;
+  getRowProps?: ((item: T) => React.HTMLAttributes<HTMLElement>) | undefined;
   id: string;
   columns: Columns<T>;
   actionButtons?: undefined | Array<ActionButtonSchema<T>> | undefined;
@@ -110,6 +111,7 @@ const TableBody: TableBodyFunction = <T extends GenericObject>(
                   enableDragAndDrop={props.enableDragAndDrop}
                   key={i}
                   item={item}
+                  rowProps={props.getRowProps?.(item)}
                   columns={props.columns}
                   actionButtons={props.actionButtons}
                   dragDropIdField={props.dragDropIdField}
@@ -143,6 +145,7 @@ const TableBody: TableBodyFunction = <T extends GenericObject>(
                 enableDragAndDrop={props.enableDragAndDrop}
                 key={i}
                 item={item}
+                rowProps={props.getRowProps?.(item)}
                 columns={props.columns}
                 actionButtons={props.actionButtons}
                 dragDropIdField={props.dragDropIdField}

package/UI/Components/Table/TableRow.tsx

@@ -21,6 +21,7 @@ import LongTextViewer from "../LongText/LongTextViewer";
 
 export interface ComponentProps<T extends GenericObject> {
   item: T;
+  rowProps?: React.HTMLAttributes<HTMLElement> | undefined;
   columns: Columns<T>;
   actionButtons?: Array<ActionButtonSchema<T>> | undefined;
   enableDragAndDrop?: boolean | undefined;
@@ -164,9 +165,10 @@ const TableRow: TableRowFunction = <T extends GenericObject>(
       return (
         <>
           <div
+            {...props.rowProps}
             {...provided?.draggableProps}
             ref={provided?.innerRef}
-            className="p-4 bg-white border-b border-gray-200"
+            className={`p-4 bg-white border-b border-gray-200 ${props.rowProps?.className || ""}`}
           >
             {props.enableDragAndDrop ? (
               <div
@@ -377,7 +379,11 @@ const TableRow: TableRowFunction = <T extends GenericObject>(
     // Desktop view: render as table row
     return (
       <>
-        <tr {...provided?.draggableProps} ref={provided?.innerRef}>
+        <tr
+          {...props.rowProps}
+          {...provided?.draggableProps}
+          ref={provided?.innerRef}
+        >
           {props.enableDragAndDrop && (
             <td
               className="ml-5 py-4 w-10 align-top"

package/UI/Components/Telemetry/TelemetryRetentionConfigForm.tsx

@@ -56,6 +56,14 @@ const TelemetryRetentionConfigForm: FunctionComponent<ComponentProps> = (
     }
   };
 
+  /*
+   * Truncate FIRST, then judge. Checking positivity before truncating let
+   * anything in (0, 1) through - "0.9" is greater than zero, and
+   * Math.trunc(0.9) is 0, so the form emitted a retention of zero days and
+   * the next sweep would delete that pillar's telemetry outright. Whole days
+   * are the only unit this configuration has, so a value that is not at
+   * least one day is not a retention at all; it is an empty field.
+   */
   const parsePositiveOrNull: (raw: string) => number | null = (
     raw: string,
   ): number | null => {
@@ -63,10 +71,14 @@ const TelemetryRetentionConfigForm: FunctionComponent<ComponentProps> = (
       return null;
     }
     const parsed: number = Number(raw);
-    if (!Number.isFinite(parsed) || parsed <= 0) {
+    if (!Number.isFinite(parsed)) {
       return null;
     }
-    return Math.trunc(parsed);
+    const days: number = Math.trunc(parsed);
+    if (days <= 0) {
+      return null;
+    }
+    return days;
   };
 
   const setPillarDefault: (

package/UI/Styles/Theme.css

@@ -948,6 +948,7 @@ html.dark :is(
     [class~="hover:bg-green-100"],
     [class~="hover:bg-emerald-100"],
     [class~="hover:bg-blue-50"],
+    [class~="hover:bg-blue-100"],
     [class~="hover:bg-rose-50"],
     [class~="hover:bg-rose-100"]
   ):hover {