@oneuptime/common 11.5.12 → 11.6.0

package/UI/Components/ModelTable/BaseModelTable.tsx

@@ -53,6 +53,10 @@ import TableColumn from "../Table/Types/Column";
 import FieldType from "../Types/FieldType";
 import ModelTableColumn from "./Column";
 import Columns from "./Columns";
+import {
+  getRelationSelectFromColumns,
+  getSelectFromColumns,
+} from "./SelectFromColumns";
 import AnalyticsBaseModel, {
   AnalyticsBaseModelType,
 } from "../../../Models/AnalyticsModels/AnalyticsBaseModel/AnalyticsBaseModel";
@@ -664,33 +668,10 @@ const BaseModelTable: <TBaseModel extends BaseModel | AnalyticsBaseModel>(
 
   const getRelationSelect: GetRelationSelectFunction =
     (): Select<TBaseModel> => {
-      const relationSelect: Select<TBaseModel> = {};
-
-      for (const column of props.columns || []) {
-        const key: string | null = column.field
-          ? (Object.keys(column.field)[0] as string)
-          : null;
-
-        if (key && model.isFileColumn(key)) {
-          (relationSelect as JSONObject)[key] = {
-            file: true,
-            _id: true,
-            fileType: true,
-            name: true,
-          };
-        } else if (key && model.isEntityColumn(key)) {
-          if (!(relationSelect as JSONObject)[key]) {
-            (relationSelect as JSONObject)[key] = {};
-          }
-
-          (relationSelect as JSONObject)[key] = {
-            ...((relationSelect as JSONObject)[key] as JSONObject),
-            ...(column.field as any)[key],
-          };
-        }
-      }
-
-      return relationSelect;
+      return getRelationSelectFromColumns<TBaseModel>({
+        columns: props.columns || [],
+        model: model,
+      });
     };
 
   type DeleteItemFunction = (item: TBaseModel) => Promise<void>;
@@ -1226,25 +1207,13 @@ const BaseModelTable: <TBaseModel extends BaseModel | AnalyticsBaseModel>(
   type GetSelectFunction = () => Select<TBaseModel>;
 
   const getSelect: GetSelectFunction = (): Select<TBaseModel> => {
-    const selectFields: Select<TBaseModel> = {
-      _id: true,
-    };
-
-    for (const column of props.columns || []) {
-      const key: string | null = column.field
-        ? (Object.keys(column.field)[0] as string)
-        : null;
-
-      if (key) {
-        if (model.hasColumn(key)) {
-          (selectFields as Dictionary<boolean>)[key] = true;
-        } else {
-          throw new BadDataException(
-            `${key} column not found on ${model.singularName}`,
-          );
-        }
-      }
-    }
+    const selectFields: Select<TBaseModel> = getSelectFromColumns<TBaseModel>({
+      columns: props.columns || [],
+      model: model,
+      hasPermissionToReadField: (field: string): boolean => {
+        return hasPermissionToReadField(field as keyof TBaseModel);
+      },
+    });
 
     const selectMoreFields: Array<keyof TBaseModel> = props.selectMoreFields
       ? (Object.keys(props.selectMoreFields) as Array<keyof TBaseModel>)

package/UI/Components/ModelTable/SelectFromColumns.ts

@@ -0,0 +1,129 @@
+import Columns from "./Columns";
+import AnalyticsBaseModel from "../../../Models/AnalyticsModels/AnalyticsBaseModel/AnalyticsBaseModel";
+import BaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import Select from "../../../Types/BaseDatabase/Select";
+import Dictionary from "../../../Types/Dictionary";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import { JSONObject } from "../../../Types/JSON";
+import { Logger } from "../../Utils/Logger";
+
+/*
+ * Builds the API `select` for a ModelTable from its column definitions.
+ *
+ * A column may declare MORE THAN ONE field when its cell renders a value
+ * composed from several columns — e.g. a "Nodes" cell that renders
+ * `{onlineNodeCount}/{nodeCount} online` declares
+ * `field: { nodeCount: true, onlineNodeCount: true }`.
+ *
+ * These used to select only the FIRST key, which left every other declared
+ * field `undefined` on the fetched row, so such cells silently rendered
+ * their zero/empty fallback — a fully online Proxmox cluster displayed
+ * "0/3 online" (OneUptime/oneuptime#2756). ModelDetail has always selected
+ * every declared key; these helpers keep ModelTable in sync with it.
+ */
+
+export function getSelectFromColumns<
+  TBaseModel extends BaseModel | AnalyticsBaseModel,
+>(data: {
+  columns: Columns<TBaseModel>;
+  model: TBaseModel;
+  /*
+   * Secondary fields are gated on this. The API rejects the WHOLE request
+   * with NotAuthorizedException when the select names a column the caller
+   * cannot read (Common/Server/Types/Database/Permissions/SelectPermission
+   * .checkSelectPermission), so a secondary field the user has no read
+   * permission on must be dropped rather than blank the table for them.
+   * Primary fields are left exactly as they always were.
+   */
+  hasPermissionToReadField?: ((field: string) => boolean) | undefined;
+}): Select<TBaseModel> {
+  const selectFields: Select<TBaseModel> = {
+    _id: true,
+  };
+
+  for (const column of data.columns) {
+    if (!column.field) {
+      continue;
+    }
+
+    const keys: Array<string> = Object.keys(column.field);
+
+    for (const key of keys) {
+      const isPrimaryField: boolean = key === keys[0];
+
+      if (!data.model.hasColumn(key)) {
+        if (isPrimaryField) {
+          /*
+           * Only the primary field is a hard error — it is also the key
+           * used for sorting and for the default cell renderer, so a bad
+           * one is a genuine mistake.
+           */
+          throw new BadDataException(
+            `${key} column not found on ${data.model.singularName}`,
+          );
+        }
+
+        /*
+         * A stray secondary key degrades to "not selected" rather than
+         * throwing, because throwing here blanks the entire page. Log it:
+         * silently dropping it is what produced #2756 in the first place.
+         */
+        Logger.error(
+          `ModelTable column "${column.title}" on ${data.model.singularName} declares field "${key}", which is not a column on the model. It will not be fetched, so the cell will render its empty value.`,
+        );
+        continue;
+      }
+
+      if (
+        !isPrimaryField &&
+        data.hasPermissionToReadField &&
+        !data.hasPermissionToReadField(key)
+      ) {
+        continue;
+      }
+
+      (selectFields as Dictionary<boolean>)[key] = true;
+    }
+  }
+
+  return selectFields;
+}
+
+export function getRelationSelectFromColumns<
+  TBaseModel extends BaseModel | AnalyticsBaseModel,
+>(data: {
+  columns: Columns<TBaseModel>;
+  model: TBaseModel;
+}): Select<TBaseModel> {
+  const relationSelect: Select<TBaseModel> = {};
+
+  for (const column of data.columns) {
+    if (!column.field) {
+      continue;
+    }
+
+    /*
+     * Same multi-field contract as getSelectFromColumns: one cell can
+     * render several relations (e.g. an alert "Resource" cell spanning
+     * hosts / kubernetesClusters / dockerHosts / podmanHosts / services).
+     */
+    for (const key of Object.keys(column.field)) {
+      if (data.model.isFileColumn(key)) {
+        (relationSelect as JSONObject)[key] = {
+          file: true,
+          _id: true,
+          fileType: true,
+          name: true,
+        };
+      } else if (data.model.isEntityColumn(key)) {
+        (relationSelect as JSONObject)[key] = {
+          ...(((relationSelect as JSONObject)[key] as JSONObject) || {}),
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          ...((column.field as any)[key] as JSONObject),
+        };
+      }
+    }
+  }
+
+  return relationSelect;
+}

package/UI/Components/Workflow/ArgumentsForm.tsx

@@ -5,6 +5,7 @@ import FormFieldSchemaType from "../Forms/Types/FormFieldSchemaType";
 import { CustomElementProps } from "../Forms/Types/Field";
 import FormValues from "../Forms/Types/FormValues";
 import ComponentValuePickerModal from "./ComponentValuePickerModal";
+import CronScheduleField from "./CronScheduleField";
 import ModelFieldPicker from "./ModelFieldPicker";
 import { componentInputTypeToFormFieldType } from "./Utils";
 import VariableModal from "./VariableModal";
@@ -198,40 +199,75 @@ const ArgumentsForm: FunctionComponent<ComponentProps> = (
                     arg.type === ComponentInputType.Select &&
                     Boolean(component.metadata.tableName);
 
-                  const baseField: {
+                  /*
+                   * The Schedule trigger's CronTab argument gets a dedicated
+                   * cron picker (presets, custom expression with live preview,
+                   * or a variable reference) instead of a bare dropdown.
+                   */
+                  const useCronPicker: boolean =
+                    arg.type === ComponentInputType.CronTab;
+
+                  let baseField: {
                     fieldType: import("../Forms/Types/FormFieldSchemaType").default;
                     dropdownOptions?: Array<DropdownOption> | undefined;
                     getCustomElement?: (
                       values: FormValues<JSONObject>,
                       customProps: CustomElementProps,
                     ) => ReactElement | undefined;
-                  } = useFieldPicker
-                    ? {
-                        fieldType: FormFieldSchemaType.CustomComponent,
-                        getCustomElement: (
-                          _values: FormValues<JSONObject>,
-                          customProps: CustomElementProps,
-                        ): ReactElement => {
-                          return (
-                            <ModelFieldPicker
-                              tableName={component.metadata.tableName as string}
-                              initialValue={customProps.initialValue}
-                              onChange={(value: string) => {
-                                void customProps.onChange?.(value);
-                              }}
-                              placeholder={customProps.placeholder}
-                              error={customProps.error}
-                              tabIndex={customProps.tabIndex}
-                            />
-                          );
-                        },
-                      }
-                    : componentInputTypeToFormFieldType(
-                        arg.type,
-                        component.arguments && component.arguments[arg.id]
-                          ? component.arguments[arg.id]
-                          : null,
-                      );
+                  };
+
+                  if (useFieldPicker) {
+                    baseField = {
+                      fieldType: FormFieldSchemaType.CustomComponent,
+                      getCustomElement: (
+                        _values: FormValues<JSONObject>,
+                        customProps: CustomElementProps,
+                      ): ReactElement => {
+                        return (
+                          <ModelFieldPicker
+                            tableName={component.metadata.tableName as string}
+                            initialValue={customProps.initialValue}
+                            onChange={(value: string) => {
+                              void customProps.onChange?.(value);
+                            }}
+                            placeholder={customProps.placeholder}
+                            error={customProps.error}
+                            tabIndex={customProps.tabIndex}
+                          />
+                        );
+                      },
+                    };
+                  } else if (useCronPicker) {
+                    baseField = {
+                      fieldType: FormFieldSchemaType.CustomComponent,
+                      getCustomElement: (
+                        _values: FormValues<JSONObject>,
+                        customProps: CustomElementProps,
+                      ): ReactElement => {
+                        return (
+                          <CronScheduleField
+                            workflowId={props.workflowId}
+                            initialValue={
+                              customProps.initialValue as string | null
+                            }
+                            onChange={(value: string) => {
+                              void customProps.onChange?.(value);
+                            }}
+                            placeholder={customProps.placeholder}
+                            error={customProps.error}
+                            tabIndex={customProps.tabIndex}
+                          />
+                        );
+                      },
+                    };
+                  } else {
+                    baseField = componentInputTypeToFormFieldType(
+                      arg.type,
+                      component.arguments && component.arguments[arg.id]
+                        ? component.arguments[arg.id]
+                        : null,
+                    );
+                  }
 
                   /*
                    * For WorkflowSelect, inject the dynamically fetched list
@@ -244,10 +280,12 @@ const ArgumentsForm: FunctionComponent<ComponentProps> = (
                   /*
                    * The "pick from component / variable" footer doesn't
                    * apply to the field picker (it edits a structured object,
-                   * not a free-text expression) or to WorkflowSelect.
+                   * not a free-text expression), to WorkflowSelect, or to the
+                   * cron picker (which has its own built-in variable selector,
+                   * and a schedule can't reference component return values).
                    */
                   const showVariableFooter: boolean =
-                    !isWorkflowSelect && !useFieldPicker;
+                    !isWorkflowSelect && !useFieldPicker && !useCronPicker;
 
                   return {
                     title: `${arg.name}`,