@oneuptime/common 14.0.12 → 14.0.13

package/UI/Utils/GrantablePermission.ts

@@ -0,0 +1,197 @@
+import PermissionScope from "../../Types/Database/AccessControl/PermissionScope";
+import Permission, {
+  UserGlobalAccessPermission,
+  UserPermission,
+  UserTenantAccessPermission,
+} from "../../Types/Permission";
+import PermissionUtil from "./Permission";
+import User from "./User";
+
+/*
+ * WHAT A USER MAY HAND ON: the dashboard's copy of the server's grant
+ * ceiling, for the defaults it offers.
+ *
+ * Giving someone a permission is delegation. Inviting a person to a team
+ * hands them that team's permissions, and adding a role to an API key hands
+ * the key that role, so the server allows either only when the person doing
+ * it holds the permission themselves (TeamPermissionService
+ * .assertCanGrantPermission, behind invitations, and ApiKeyPermissionService
+ * .assertCallerCanGrantPermission):
+ *
+ *   - a project owner may hand on anything, unless something blocks their
+ *     ProjectOwner;
+ *   - anyone else only a permission they hold for the whole project (scope
+ *     All, or no label restriction - never Owned), and not one they are
+ *     blocked from.
+ *
+ * A form that preselects a team or offers a role uses this to offer only
+ * what the server would accept, so a default never ends in "You cannot
+ * grant ...". It covers grants that reach the whole project, the only kind
+ * a default makes, and it is never looser than the server: what it says yes
+ * to, the server accepts. A no only means the default is not offered - the
+ * person can still pick the team or the role by hand, and the server
+ * explains its own refusal. That is why a row whose kind is unknown counts
+ * as a block here and never as an allow.
+ */
+
+export interface PermissionRows {
+  allow: Array<UserPermission>;
+  block: Array<UserPermission>;
+}
+
+type IsUnrestrictedFunction = (permission: UserPermission) => boolean;
+
+/*
+ * A row that reaches the whole project: scope All, or (Labels, or a legacy
+ * row with no scope) with no labels on it. Owned never does: an owned-only
+ * grant cannot be handed on as a project-wide one.
+ */
+export const isUnrestrictedPermission: IsUnrestrictedFunction = (
+  permission: UserPermission,
+): boolean => {
+  if (permission.scope === PermissionScope.All) {
+    return true;
+  }
+
+  if (permission.scope === PermissionScope.Owned) {
+    return false;
+  }
+
+  return (permission.labelIds || []).length === 0;
+};
+
+type HoldsUnblockedFunction = (data: {
+  permission: Permission;
+  rows: PermissionRows;
+}) => boolean;
+
+/*
+ * Held for the whole project, and not blocked at all - a block with labels
+ * still takes part of the project away from a project-wide grant.
+ */
+const holdsUnblocked: HoldsUnblockedFunction = (data: {
+  permission: Permission;
+  rows: PermissionRows;
+}): boolean => {
+  const isHeld: boolean = data.rows.allow.some(
+    (row: UserPermission): boolean => {
+      return (
+        row.permission === data.permission && isUnrestrictedPermission(row)
+      );
+    },
+  );
+
+  if (!isHeld) {
+    return false;
+  }
+
+  return !data.rows.block.some((row: UserPermission): boolean => {
+    return row.permission === data.permission;
+  });
+};
+
+type CanGrantPermissionFunction = (data: {
+  permission: Permission;
+  rows: PermissionRows;
+}) => boolean;
+
+/**
+ * Whether someone holding `rows` may hand `permission` on to a team member or
+ * an API key, for the whole project.
+ */
+export const canGrantPermission: CanGrantPermissionFunction = (data: {
+  permission: Permission;
+  rows: PermissionRows;
+}): boolean => {
+  if (
+    holdsUnblocked({
+      permission: Permission.ProjectOwner,
+      rows: data.rows,
+    })
+  ) {
+    return true;
+  }
+
+  return holdsUnblocked(data);
+};
+
+type ToPermissionRowsFunction = (data: {
+  projectPermissions: UserTenantAccessPermission | null;
+  globalPermissions: UserGlobalAccessPermission | null;
+}) => PermissionRows;
+
+/*
+ * The signed-in user's permissions as the server reads them for a request in
+ * this project: the global ones count as project-wide allows, and the
+ * project's own rows split into allows and blocks.
+ */
+export const toPermissionRows: ToPermissionRowsFunction = (data: {
+  projectPermissions: UserTenantAccessPermission | null;
+  globalPermissions: UserGlobalAccessPermission | null;
+}): PermissionRows => {
+  const allow: Array<UserPermission> = (
+    data.globalPermissions?.globalPermissions || []
+  ).map((permission: Permission): UserPermission => {
+    return {
+      permission: permission,
+      labelIds: [],
+      isBlockPermission: false,
+      _type: "UserPermission",
+    };
+  });
+
+  const block: Array<UserPermission> = [];
+
+  for (const row of data.projectPermissions?.permissions || []) {
+    // The server counts a row as an allow only when it says it is one.
+    if (row.isBlockPermission === false) {
+      allow.push(row);
+    } else {
+      block.push(row);
+    }
+  }
+
+  return { allow, block };
+};
+
+export default class GrantablePermission {
+  public static getCurrentUserPermissionRows(): PermissionRows {
+    return toPermissionRows({
+      projectPermissions: PermissionUtil.getProjectPermissions(),
+      globalPermissions: PermissionUtil.getGlobalPermissions(),
+    });
+  }
+
+  /*
+   * Whether the signed-in user may hand `permission` on. A master admin may
+   * hand on anything, as on the server.
+   */
+  public static canCurrentUserGrant(permission: Permission): boolean {
+    if (User.isMasterAdmin()) {
+      return true;
+    }
+
+    return canGrantPermission({
+      permission: permission,
+      rows: this.getCurrentUserPermissionRows(),
+    });
+  }
+
+  /*
+   * Whether the signed-in user may hand on every one of `permissions` - what
+   * inviting someone to a team takes, for each row the team has.
+   */
+  public static canCurrentUserGrantAll(
+    permissions: Array<Permission>,
+  ): boolean {
+    if (User.isMasterAdmin()) {
+      return true;
+    }
+
+    const rows: PermissionRows = this.getCurrentUserPermissionRows();
+
+    return permissions.every((permission: Permission): boolean => {
+      return canGrantPermission({ permission: permission, rows: rows });
+    });
+  }
+}

package/UI/Utils/PermissionGate.ts

@@ -6,8 +6,32 @@ import Permission, {
 } from "../../Types/Permission";
 import { ColumnAccessControl } from "../../Types/BaseDatabase/AccessControl";
 import PermissionUtil from "./Permission";
+import {
+  getGlobalTranslator,
+  translatableTerm,
+  translationKey,
+  Translator,
+} from "./TranslateTemplate";
 import User from "./User";
 
+/*
+ * The tooltip's first sentence for each operation, translated whole with the
+ * model's name in it. A table that names its own verb ("unlink") gets the
+ * verb-and-name template instead.
+ */
+const MISSING_PERMISSION_TEMPLATES: Record<string, string> = {
+  create: translationKey(
+    "You do not have permission to create this {{itemName}}.",
+  ),
+  read: translationKey("You do not have permission to read this {{itemName}}."),
+  update: translationKey(
+    "You do not have permission to update this {{itemName}}.",
+  ),
+  delete: translationKey(
+    "You do not have permission to delete this {{itemName}}.",
+  ),
+};
+
 /*
  * The four record-level operations a user can be gated on. Deliberately not the
  * column-level equivalents: field access control stays hidden rather than
@@ -189,13 +213,35 @@ export default class PermissionGate {
       this.getModelPermissions(model, action),
     );
 
+    const translator: Translator = getGlobalTranslator();
+    const template: string | undefined = MISSING_PERMISSION_TEMPLATES[verb];
+
+    const sentence: string = template
+      ? translator.translateTemplate(template, {
+          itemName: translatableTerm(singularName),
+        })
+      : translator.translateTemplate(
+          "You do not have permission to {{action}} this {{itemName}}.",
+          {
+            action: translatableTerm(verb),
+            itemName: translatableTerm(singularName),
+          },
+        );
+
     if (titles.length === 0) {
-      return `You do not have permission to ${verb} this ${singularName}.`;
+      return sentence;
     }
 
-    return `You do not have permission to ${verb} this ${singularName}. You need one of these permissions: ${titles.join(
-      ", ",
-    )}.`;
+    return `${sentence} ${translator.translateTemplate(
+      "You need one of these permissions: {{permissions}}.",
+      {
+        permissions: titles
+          .map((title: string): string => {
+            return translator.translateText(title) || title;
+          })
+          .join(", "),
+      },
+    )}`;
   }
 
   public static getModelPermissions(

package/UI/Utils/Rules/RuleRunClient.ts

@@ -13,6 +13,7 @@ import {
 import RuleRunSummary from "../../../Utils/Rules/RuleRunSummary";
 import { APP_API_URL } from "../../Config";
 import API from "../API/API";
+import { translateTemplate, translateText } from "../TranslateTemplate";
 
 /*
  * The dashboard half of "Run now" for label, owner, privacy and status page
@@ -63,7 +64,9 @@ export default class RuleRunClient {
     if (!data.ruleId) {
       return {
         isSuccess: false,
-        message: "This rule has no id, so it cannot be run.",
+        message:
+          translateText("This rule has no id, so it cannot be run.") ||
+          "This rule has no id, so it cannot be run.",
         result: null,
       };
     }
@@ -94,9 +97,16 @@ export default class RuleRunClient {
 
       return {
         isSuccess: false,
-        message: `${message} The run stopped part-way. Before it stopped: ${RuleRunSummary.describe(
-          { ruleType: data.ruleType, result: partial },
-        )}`,
+        message: translateTemplate(
+          "{{message}} The run stopped part-way. Before it stopped: {{summary}}",
+          {
+            message: message,
+            summary: RuleRunSummary.describe({
+              ruleType: data.ruleType,
+              result: partial,
+            }),
+          },
+        ),
         result: partial,
       };
     };

package/UI/Utils/Telemetry/ResultTotal.ts

@@ -0,0 +1,150 @@
+import HTTPErrorResponse from "../../../Types/API/HTTPErrorResponse";
+
+/*
+ * How many rows a telemetry explorer's query matches — the "712,345 spans"
+ * above the traces list (issue #4202).
+ *
+ * The analytics list endpoints do not say. They skip COUNT(*), which on a
+ * wide window scans every matching row, and answer with one page plus
+ * whether more rows follow; the `count` they return is a lower bound
+ * (`skip + rows + 1`). The explorers used to print that bound as the total —
+ * "Showing 1-50 of 51 traces" over a project with hundreds of thousands —
+ * so a total is now worked out apart from the list: proven by the page
+ * itself when it is the last one, and counted exactly otherwise.
+ */
+
+export enum ResultTotalStatus {
+  // The list it describes has not answered yet, or the count is running.
+  Counting = "counting",
+  // `count` is how many rows the query matches.
+  Exact = "exact",
+  // It could not be counted; `unavailableReason` says why.
+  Unavailable = "unavailable",
+}
+
+export enum ResultTotalUnavailableReason {
+  // The server stopped counting at its time limit: too many rows to count.
+  TooManyToCount = "too-many-to-count",
+  // The count request failed for any other reason.
+  CountFailed = "count-failed",
+}
+
+export interface ResultTotal {
+  status: ResultTotalStatus;
+  // Set when the status is Exact.
+  count?: number | undefined;
+  // Set when the status is Unavailable.
+  unavailableReason?: ResultTotalUnavailableReason | undefined;
+}
+
+// The page a list request committed, as far as a total is concerned.
+export interface ResultTotalListPage {
+  // Rows the page holds.
+  rowCount: number;
+  // Rows before it: the request's skip.
+  skip: number;
+  /*
+   * The list endpoint's answer to "do more rows follow this page". Undefined
+   * when it did not say, and then the page proves nothing about the total.
+   */
+  hasMore: boolean | undefined;
+}
+
+export default class ResultTotalUtil {
+  /*
+   * The total a page proves on its own, or null when only a count can tell.
+   * A page nothing follows has seen every row: the ones skipped to reach it
+   * and its own. Except a page past the end of the list (an old link to page
+   * 40 of what is now 3 pages) — it holds nothing, and the rows before it are
+   * then not known to be `skip`.
+   */
+  public static getTotalProvenByPage(page: ResultTotalListPage): number | null {
+    if (page.hasMore !== false) {
+      return null;
+    }
+
+    if (page.rowCount === 0 && page.skip > 0) {
+      return null;
+    }
+
+    return page.skip + page.rowCount;
+  }
+
+  /*
+   * The fewest rows a page proves exist: everything up to its last row, and
+   * one more when the endpoint saw another after it. An empty page proves
+   * nothing — not even that the rows it skipped exist.
+   */
+  public static getLowerBoundProvenByPage(page: ResultTotalListPage): number {
+    if (page.rowCount === 0) {
+      return 0;
+    }
+
+    return page.skip + page.rowCount + (page.hasMore ? 1 : 0);
+  }
+
+  /*
+   * Why a count request failed, in the terms the explorers explain it in. The
+   * API answers an exact count that ran out of time with 408.
+   */
+  public static getUnavailableReason(
+    error: unknown,
+  ): ResultTotalUnavailableReason {
+    if (error instanceof HTTPErrorResponse && error.statusCode === 408) {
+      return ResultTotalUnavailableReason.TooManyToCount;
+    }
+
+    return ResultTotalUnavailableReason.CountFailed;
+  }
+
+  /*
+   * The total a pager may number its pages by and print as "of N", or
+   * undefined while there is none — the pager then pages forward on
+   * `hasMore` instead. A caller tracking the result total has one once it is
+   * exact. One that only says whether more rows follow has one exactly when
+   * its page ends the list. One that says neither passes an exact count (a
+   * Postgres-backed list), as every explorer used to.
+   */
+  public static getPagingTotal(input: {
+    resultTotal?: ResultTotal | undefined;
+    hasMore?: boolean | undefined;
+    // The list's own count: exact, or a lower bound when `hasMore` is set.
+    totalCount: number;
+    // The rows this page holds, and the rows before it.
+    rowCount: number;
+    skip: number;
+  }): number | undefined {
+    if (input.resultTotal) {
+      return input.resultTotal.status === ResultTotalStatus.Exact
+        ? input.resultTotal.count || 0
+        : undefined;
+    }
+
+    if (input.hasMore === undefined) {
+      return input.totalCount;
+    }
+
+    return (
+      ResultTotalUtil.getTotalProvenByPage({
+        rowCount: input.rowCount,
+        skip: input.skip,
+        hasMore: input.hasMore,
+      }) ?? undefined
+    );
+  }
+
+  /*
+   * The count, if there is one. A count lower than what the page itself
+   * proves is stale — rows arrived or expired between the two requests — and
+   * is raised to the proof rather than printing "50 of 40".
+   */
+  public static reconcileCount(
+    count: number,
+    page: ResultTotalListPage,
+  ): number {
+    const safeCount: number =
+      Number.isFinite(count) && count > 0 ? Math.floor(count) : 0;
+
+    return Math.max(safeCount, ResultTotalUtil.getLowerBoundProvenByPage(page));
+  }
+}

package/UI/Utils/Telemetry/UseResultTotal.ts

@@ -0,0 +1,173 @@
+import React, { useEffect, useRef, useState } from "react";
+import ResultTotalUtil, {
+  ResultTotal,
+  ResultTotalListPage,
+  ResultTotalStatus,
+} from "./ResultTotal";
+
+// A page the list committed, and the query it was fetched with.
+export interface ResultTotalListAnswer<TQuery> {
+  query: TQuery;
+  page: ResultTotalListPage;
+}
+
+export interface UseResultTotalOptions<TQuery> {
+  /*
+   * The list's query. A new object is a new result set: its total is worked
+   * out afresh. Keep it memoized — a query rebuilt on every render would be
+   * counted on every render.
+   */
+  query: TQuery;
+  /*
+   * The newest page the list committed. Only a page fetched with `query`
+   * says anything about its total; until one arrives the total is counting.
+   */
+  listAnswer: ResultTotalListAnswer<TQuery> | null;
+  // Counts every row `query` matches. Rejects when it cannot.
+  countRows: (query: TQuery) => Promise<number>;
+  /*
+   * False while the list is not on screen (an explorer's analytics view):
+   * nothing is counted for a total nobody can see.
+   */
+  isEnabled?: boolean | undefined;
+  /*
+   * Bump to count the same query again — the Refresh button, a live poll.
+   * The last total stays on screen until the new one lands, so a live view
+   * does not flash "Counting" on every beat.
+   */
+  refreshKey?: number | undefined;
+}
+
+interface CountedTotal<TQuery> {
+  query: TQuery;
+  refreshKey: number;
+  total: ResultTotal;
+}
+
+interface CountRequest<TQuery> {
+  query: TQuery;
+  sequence: number;
+}
+
+/*
+ * The total of a telemetry explorer's result set (see ResultTotal). A list
+ * page that ends the list proves it outright, so most narrow searches never
+ * ask for a count; otherwise the rows are counted once per query, apart from
+ * the list, so a slow count never holds the list back.
+ */
+export default function useResultTotal<TQuery>(
+  options: UseResultTotalOptions<TQuery>,
+): ResultTotal {
+  const isEnabled: boolean = options.isEnabled ?? true;
+  const refreshKey: number = options.refreshKey ?? 0;
+
+  const [counted, setCounted] = useState<CountedTotal<TQuery> | null>(null);
+
+  const inFlightRef: React.MutableRefObject<CountRequest<TQuery> | null> =
+    useRef<CountRequest<TQuery> | null>(null);
+  const sequenceRef: React.MutableRefObject<number> = useRef<number>(0);
+
+  // Usually an inline arrow: read the newest one without re-running on it.
+  const countRowsRef: React.MutableRefObject<
+    (query: TQuery) => Promise<number>
+  > = useRef<(query: TQuery) => Promise<number>>(options.countRows);
+  countRowsRef.current = options.countRows;
+
+  const page: ResultTotalListPage | null =
+    options.listAnswer && options.listAnswer.query === options.query
+      ? options.listAnswer.page
+      : null;
+
+  const provenTotal: number | null = page
+    ? ResultTotalUtil.getTotalProvenByPage(page)
+    : null;
+
+  const needsCount: boolean =
+    isEnabled && page !== null && provenTotal === null;
+
+  const isUpToDate: boolean = Boolean(
+    counted &&
+      counted.query === options.query &&
+      counted.refreshKey === refreshKey,
+  );
+
+  useEffect(() => {
+    if (!needsCount || isUpToDate) {
+      return;
+    }
+
+    /*
+     * One count per query at a time. A refresh that lands while one is out
+     * waits for it rather than replacing it: on a count slower than the live
+     * poll, replacing would drop every answer. Its landing re-runs this
+     * effect, which then counts again for the newer refresh.
+     */
+    if (inFlightRef.current && inFlightRef.current.query === options.query) {
+      return;
+    }
+
+    const query: TQuery = options.query;
+    const requestedRefreshKey: number = refreshKey;
+    const sequence: number = ++sequenceRef.current;
+
+    inFlightRef.current = { query, sequence };
+
+    const commit: (total: ResultTotal) => void = (total: ResultTotal): void => {
+      // A newer query asked meanwhile: its count is the one that matters.
+      if (sequenceRef.current !== sequence) {
+        return;
+      }
+
+      inFlightRef.current = null;
+      setCounted({ query, refreshKey: requestedRefreshKey, total });
+    };
+
+    let request: Promise<number>;
+
+    // A count that throws before it starts is a failed count, not a crash.
+    try {
+      request = countRowsRef.current(query);
+    } catch (error) {
+      request = Promise.reject(error);
+    }
+
+    request.then(
+      (count: number) => {
+        commit({ status: ResultTotalStatus.Exact, count });
+      },
+      (error: unknown) => {
+        commit({
+          status: ResultTotalStatus.Unavailable,
+          unavailableReason: ResultTotalUtil.getUnavailableReason(error),
+        });
+      },
+    );
+    /*
+     * `counted` is here so a landing re-runs the effect: when a refresh came
+     * while the count was out, nothing else changes when that count lands.
+     */
+  }, [needsCount, isUpToDate, options.query, refreshKey, counted]);
+
+  if (!page) {
+    return { status: ResultTotalStatus.Counting };
+  }
+
+  if (provenTotal !== null) {
+    return { status: ResultTotalStatus.Exact, count: provenTotal };
+  }
+
+  if (!counted || counted.query !== options.query) {
+    return { status: ResultTotalStatus.Counting };
+  }
+
+  if (counted.total.status === ResultTotalStatus.Exact) {
+    // Current, or the last one standing in while a refresh recounts.
+    return {
+      status: ResultTotalStatus.Exact,
+      count: ResultTotalUtil.reconcileCount(counted.total.count || 0, page),
+    };
+  }
+
+  // A failure is only shown for the refresh it answered.
+  return isUpToDate ? counted.total : { status: ResultTotalStatus.Counting };
+}