@oneuptime/common 12.0.0 → 12.0.2

package/UI/Utils/ModelAPI/ProjectUsersModelAPI.ts

@@ -0,0 +1,305 @@
+import ModelAPI, { ListResult, RequestOptions } from "./ModelAPI";
+import TeamMembersByUser, { ProjectUserRow } from "../TeamMembersByUser";
+import API from "../API/API";
+import { APP_API_URL } from "../../Config";
+import BaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import TeamMember from "../../../Models/DatabaseModels/TeamMember";
+import HTTPErrorResponse from "../../../Types/API/HTTPErrorResponse";
+import HTTPResponse from "../../../Types/API/HTTPResponse";
+import URL from "../../../Types/API/URL";
+import { JSONObject } from "../../../Types/JSON";
+import GroupBy from "../../../Types/BaseDatabase/GroupBy";
+import Includes from "../../../Types/BaseDatabase/Includes";
+import Query from "../../../Types/BaseDatabase/Query";
+import Select from "../../../Types/BaseDatabase/Select";
+import Sort from "../../../Types/BaseDatabase/Sort";
+import { LIMIT_PER_PROJECT } from "../../../Types/Database/LimitMax";
+import ObjectID from "../../../Types/ObjectID";
+
+/*
+ * A drop-in ModelAPI for tables that list TeamMember but mean to list *people*
+ * - the project's Users table being the one that does.
+ *
+ * TeamMember rows are (user, team) pairs, so the plain API pages over
+ * memberships: a user on three teams occupies three rows and reads as three
+ * different people with the same name. This API pages over users instead. It
+ * reads the project's memberships, folds them into one row per user (see
+ * TeamMembersByUser), and then applies the table's skip/limit to *that* list,
+ * so `count` is a number of people and every page boundary falls between two
+ * people rather than between two of one person's teams.
+ *
+ * Paging cannot be pushed to the server here: the list endpoint has no DISTINCT
+ * or GROUP BY, so there is no way to ask it for the Nth user. Reading the whole
+ * membership list up front is what the project user pickers already do.
+ *
+ * Deleting is redefined to match what a row now means - see deleteItem.
+ */
+export default class ProjectUsersModelAPI extends ModelAPI {
+  public static override async getList<TBaseModel extends BaseModel>(data: {
+    modelType: { new (): TBaseModel };
+    query: Query<TBaseModel>;
+    groupBy?: GroupBy<TBaseModel> | undefined;
+    limit: number;
+    skip: number;
+    select: Select<TBaseModel>;
+    sort: Sort<TBaseModel>;
+    requestOptions?: RequestOptions | undefined;
+  }): Promise<ListResult<TBaseModel>> {
+    if (!(new data.modelType() instanceof TeamMember)) {
+      // Not the model this API exists for. Behave like the plain one.
+      return ModelAPI.getList<TBaseModel>(data);
+    }
+
+    const query: Query<TeamMember> = data.query as Query<TeamMember>;
+    const sort: Sort<TeamMember> = data.sort as Sort<TeamMember>;
+
+    const memberships: Array<TeamMember> = await this.readAllMemberships({
+      query: query,
+      select: this.getMembershipSelect(data.select as Select<TeamMember>),
+      sort: sort,
+      requestOptions: data.requestOptions,
+    });
+
+    let rows: Array<ProjectUserRow> =
+      TeamMembersByUser.groupByUser(memberships);
+
+    /*
+     * An explicit sort was already applied by the server and grouping kept it.
+     * Without one the server's order is arbitrary, and an arbitrary order that
+     * is then sliced into pages is worse here than elsewhere - so fall back to
+     * something a reader of a people directory expects, and that pages the same
+     * way every time.
+     */
+    if (Object.keys(sort || {}).length === 0) {
+      rows = TeamMembersByUser.sortRowsByUserName(rows);
+    }
+
+    const pageRows: Array<ProjectUserRow> = rows.slice(
+      data.skip,
+      data.skip + data.limit,
+    );
+
+    await this.fillInTeamsHiddenByFilters({
+      query: query,
+      pageRows: pageRows,
+      requestOptions: data.requestOptions,
+    });
+
+    return {
+      data: pageRows as unknown as Array<TBaseModel>,
+      count: rows.length,
+      skip: data.skip,
+      limit: data.limit,
+    };
+  }
+
+  /**
+   * Removes the user on this row from the project - every one of their team
+   * memberships, not just the one whose id the row happens to carry.
+   *
+   * A grouped row stands for a person, so deleting one membership would leave
+   * the row on screen (still a member, via their other teams) and look like the
+   * delete silently failed. Removing a user from a single team is done from
+   * that user's own Teams tab, where a row is a membership again.
+   *
+   * This goes through one `remove-user-from-project` request rather than a
+   * DELETE per membership, and that is load-bearing rather than an
+   * optimisation. The server refuses to remove the last accepted member of the
+   * Owners team, and it refuses per request - so a loop deletes every other
+   * membership first and only then reports a failure, leaving the person
+   * stripped of the teams the caller was just told they had not lost. The
+   * endpoint runs that check across the whole set before deleting anything.
+   */
+  public static override async deleteItem<TBaseModel extends BaseModel>(data: {
+    modelType: { new (): TBaseModel };
+    id: ObjectID;
+    requestOptions?: RequestOptions | undefined;
+  }): Promise<void> {
+    if (!(new data.modelType() instanceof TeamMember)) {
+      return ModelAPI.deleteItem<TBaseModel>(data);
+    }
+
+    const rowMembership: TeamMember | null = await ModelAPI.getItem<TeamMember>(
+      {
+        modelType: TeamMember,
+        id: data.id,
+        select: {
+          _id: true,
+          userId: true,
+        },
+        requestOptions: data.requestOptions,
+      },
+    );
+
+    const userId: ObjectID | undefined = rowMembership?.userId;
+
+    if (!userId) {
+      /*
+       * The row is gone, or came back without the user it stands for. Fall back
+       * to the single delete the table asked for rather than guessing.
+       */
+      return ModelAPI.deleteItem<TBaseModel>(data);
+    }
+
+    const url: URL = URL.fromString(APP_API_URL.toString())
+      .addRoute(new TeamMember().getCrudApiPath()!)
+      .addRoute("/remove-user-from-project");
+
+    const result: HTTPResponse<JSONObject> | HTTPErrorResponse =
+      await API.post<JSONObject>({
+        url: url,
+        data: {
+          userId: userId.toString(),
+        },
+        headers: ModelAPI.getCommonHeaders(data.requestOptions),
+      });
+
+    if (result instanceof HTTPErrorResponse) {
+      throw result;
+    }
+  }
+
+  /**
+   * Every membership matching the query, across as many requests as it takes.
+   *
+   * A single read would be capped at LIMIT_PER_PROJECT, and a capped read is
+   * indistinguishable here from a complete one: the grouped list would simply
+   * be missing whichever people fell outside the window, `count` would report
+   * the truncated total as authoritative, and nothing on screen would say so.
+   * Paging until a short page comes back keeps the grouping honest.
+   */
+  private static async readAllMemberships(data: {
+    query: Query<TeamMember>;
+    select: Select<TeamMember>;
+    sort: Sort<TeamMember>;
+    requestOptions?: RequestOptions | undefined;
+  }): Promise<Array<TeamMember>> {
+    const memberships: Array<TeamMember> = [];
+
+    /*
+     * A backstop, not an expected bound: every page after the first means a
+     * project with more than 10,000 memberships. Reaching it would mean
+     * something is paging without making progress.
+     */
+    const maxPages: number = 10;
+
+    for (let page: number = 0; page < maxPages; page++) {
+      const result: ListResult<TeamMember> = await ModelAPI.getList<TeamMember>(
+        {
+          modelType: TeamMember,
+          query: data.query,
+          limit: LIMIT_PER_PROJECT,
+          skip: page * LIMIT_PER_PROJECT,
+          select: data.select,
+          sort: data.sort,
+          requestOptions: data.requestOptions,
+        },
+      );
+
+      memberships.push(...result.data);
+
+      if (result.data.length < LIMIT_PER_PROJECT) {
+        // A short page is the last page.
+        break;
+      }
+    }
+
+    return memberships;
+  }
+
+  /**
+   * The table's own select plus the fields grouping needs. Columns ask for what
+   * they render; grouping also needs to know which user and which team each
+   * membership belongs to, and whether it was accepted.
+   */
+  private static getMembershipSelect(
+    select: Select<TeamMember>,
+  ): Select<TeamMember> {
+    const teamSelect: Record<string, boolean> =
+      typeof select?.team === "object" && select.team !== null
+        ? { ...(select.team as Record<string, boolean>) }
+        : {};
+
+    const userSelect: Record<string, boolean> =
+      typeof select?.user === "object" && select.user !== null
+        ? { ...(select.user as Record<string, boolean>) }
+        : {};
+
+    return {
+      ...select,
+      _id: true,
+      userId: true,
+      teamId: true,
+      hasAcceptedInvitation: true,
+      user: {
+        ...userSelect,
+        _id: true,
+      },
+      team: {
+        ...teamSelect,
+        _id: true,
+        name: true,
+      },
+    } as Select<TeamMember>;
+  }
+
+  /**
+   * When the table is filtered, the memberships that were read are only the
+   * matching ones - filter by a team and every user's Teams column would show
+   * that one team and nothing else, which is exactly the "which teams is this
+   * person on?" question the grouped row exists to answer.
+   *
+   * So for the users actually on this page (at most one page's worth), re-read
+   * their memberships unfiltered and merge the full team list back in.
+   */
+  private static async fillInTeamsHiddenByFilters(data: {
+    query: Query<TeamMember>;
+    pageRows: Array<ProjectUserRow>;
+    requestOptions?: RequestOptions | undefined;
+  }): Promise<void> {
+    const projectId: unknown = (data.query as Record<string, unknown>)[
+      "projectId"
+    ];
+
+    const isFiltered: boolean = Object.keys(data.query).some((key: string) => {
+      return key !== "projectId";
+    });
+
+    if (!isFiltered || !projectId || data.pageRows.length === 0) {
+      return;
+    }
+
+    const userIds: Array<string> = data.pageRows
+      .map((row: ProjectUserRow) => {
+        return TeamMembersByUser.getGroupKey(row) || "";
+      })
+      .filter((userId: string) => {
+        return Boolean(userId);
+      });
+
+    if (userIds.length === 0) {
+      return;
+    }
+
+    const allMemberships: Array<TeamMember> = await this.readAllMemberships({
+      query: {
+        projectId: projectId,
+        userId: new Includes(userIds),
+      } as Query<TeamMember>,
+      select: {
+        _id: true,
+        userId: true,
+        teamId: true,
+        hasAcceptedInvitation: true,
+        team: {
+          _id: true,
+          name: true,
+        },
+      } as Select<TeamMember>,
+      sort: {},
+      requestOptions: data.requestOptions,
+    });
+
+    TeamMembersByUser.mergeAllTeamsIntoRows(data.pageRows, allMemberships);
+  }
+}

package/UI/Utils/TeamMembersByUser.ts

@@ -0,0 +1,302 @@
+import Team from "../../Models/DatabaseModels/Team";
+import TeamMember from "../../Models/DatabaseModels/TeamMember";
+
+/*
+ * TeamMember is a (user, team) pair, so a list of team members is a list of
+ * memberships - not a list of people. Rendering it straight into a "Users"
+ * table gives one row per membership, and someone who belongs to three teams
+ * reads as three separate people with the same name and avatar.
+ *
+ * These helpers collapse memberships into one row per person, carrying every
+ * team that person belongs to on the row so the table can show them together.
+ * The row is still a TeamMember (the table, its columns and its delete action
+ * are all typed against the model) - it just stands for the user rather than
+ * for one of their memberships.
+ */
+
+export interface ProjectUserExtras {
+  // Every team this user belongs to, sorted by name.
+  teamsForUser: Array<Team>;
+  teamCountForUser: number;
+  /*
+   * How many of those memberships are still unaccepted invitations. A user can
+   * be a fully accepted member of one team and a pending invite on another.
+   */
+  pendingTeamCountForUser: number;
+}
+
+export type ProjectUserRow = TeamMember & ProjectUserExtras;
+
+export default class TeamMembersByUser {
+  /**
+   * The identity a membership is grouped under. Null when the row carries no
+   * user at all - those rows are never merged, because merging them would put
+   * unrelated memberships on one line.
+   */
+  public static getGroupKey(teamMember: TeamMember): string | null {
+    const userId: string =
+      teamMember.userId?.toString() || teamMember.user?._id?.toString() || "";
+
+    return userId || null;
+  }
+
+  /**
+   * The name this row sorts and reads under. Falls back to the email so a user
+   * who was invited but has not set a name yet still lands somewhere sensible.
+   */
+  public static getDisplayName(teamMember: TeamMember): string {
+    return (
+      teamMember.user?.name?.toString() ||
+      teamMember.user?.email?.toString() ||
+      ""
+    );
+  }
+
+  /**
+   * One row per user, in the order each user was first seen. The input order is
+   * whatever the server sorted by, so first-seen order keeps that sort intact.
+   *
+   * The returned rows are the same TeamMember instances that came in (the first
+   * membership seen for each user), mutated with the aggregate fields.
+   */
+  public static groupByUser(
+    teamMembers: Array<TeamMember>,
+  ): Array<ProjectUserRow> {
+    const rowsByGroupKey: Map<string, ProjectUserRow> = new Map<
+      string,
+      ProjectUserRow
+    >();
+    const rows: Array<ProjectUserRow> = [];
+
+    /*
+     * Which teams are already on a row, keyed the same way for every
+     * membership. Tracked here rather than re-derived from `teamsForUser`
+     * because a membership identifies its team by `teamId` while the team
+     * object it carries identifies itself by `_id`, and either one can be
+     * missing from a given select.
+     */
+    const teamKeysByRow: Map<ProjectUserRow, Set<string>> = new Map<
+      ProjectUserRow,
+      Set<string>
+    >();
+
+    /*
+     * Every membership id folded into each row, so the row can be given a
+     * stable identity below.
+     */
+    const membershipIdsByRow: Map<ProjectUserRow, Array<string>> = new Map<
+      ProjectUserRow,
+      Array<string>
+    >();
+
+    for (const teamMember of teamMembers) {
+      const groupKey: string | null = this.getGroupKey(teamMember);
+
+      const existingRow: ProjectUserRow | undefined = groupKey
+        ? rowsByGroupKey.get(groupKey)
+        : undefined;
+
+      if (existingRow) {
+        this.addMembershipToRow(
+          existingRow,
+          teamMember,
+          teamKeysByRow.get(existingRow)!,
+          Boolean(teamMember.hasAcceptedInvitation),
+        );
+        this.rememberMembershipId(
+          membershipIdsByRow.get(existingRow)!,
+          teamMember,
+        );
+        continue;
+      }
+
+      const row: ProjectUserRow = teamMember as ProjectUserRow;
+      const teamKeys: Set<string> = new Set<string>();
+      const membershipIds: Array<string> = [];
+
+      /*
+       * The row *is* this membership, so read its acceptance before the reset
+       * below overwrites it.
+       */
+      const hasAcceptedInvitation: boolean = Boolean(
+        teamMember.hasAcceptedInvitation,
+      );
+
+      row.teamsForUser = [];
+      row.teamCountForUser = 0;
+      row.pendingTeamCountForUser = 0;
+
+      /*
+       * Reset before folding the row's own membership back in: on a grouped row
+       * this field means "is a member of this project", which is true as soon as
+       * any one of the memberships has been accepted.
+       */
+      row.hasAcceptedInvitation = false;
+
+      teamKeysByRow.set(row, teamKeys);
+      membershipIdsByRow.set(row, membershipIds);
+      this.addMembershipToRow(row, teamMember, teamKeys, hasAcceptedInvitation);
+      this.rememberMembershipId(membershipIds, teamMember);
+
+      if (groupKey) {
+        rowsByGroupKey.set(groupKey, row);
+      }
+
+      rows.push(row);
+    }
+
+    for (const row of rows) {
+      this.finalizeRow(row, membershipIdsByRow.get(row) || []);
+    }
+
+    return rows;
+  }
+
+  /**
+   * Replaces the team aggregate on each row with the one derived from
+   * `allTeamMembers`.
+   *
+   * Needed because the rows on screen may have been built from a *filtered*
+   * membership list - filter the table by one team and grouping only ever sees
+   * that team, so the Teams column would claim each user belongs to exactly the
+   * team that was filtered for. The caller re-reads the unfiltered memberships
+   * for the users on the current page and merges them back in here.
+   *
+   * Rows with no matching membership in `allTeamMembers` are left untouched.
+   */
+  public static mergeAllTeamsIntoRows(
+    rows: Array<ProjectUserRow>,
+    allTeamMembers: Array<TeamMember>,
+  ): Array<ProjectUserRow> {
+    const groupedRows: Array<ProjectUserRow> = this.groupByUser(allTeamMembers);
+
+    const groupedRowsByKey: Map<string, ProjectUserRow> = new Map<
+      string,
+      ProjectUserRow
+    >();
+
+    for (const groupedRow of groupedRows) {
+      const groupKey: string | null = this.getGroupKey(groupedRow);
+
+      if (groupKey) {
+        groupedRowsByKey.set(groupKey, groupedRow);
+      }
+    }
+
+    for (const row of rows) {
+      const groupKey: string | null = this.getGroupKey(row);
+      const groupedRow: ProjectUserRow | undefined = groupKey
+        ? groupedRowsByKey.get(groupKey)
+        : undefined;
+
+      if (!groupedRow) {
+        continue;
+      }
+
+      row.teamsForUser = groupedRow.teamsForUser;
+      row.teamCountForUser = groupedRow.teamCountForUser;
+      row.pendingTeamCountForUser = groupedRow.pendingTeamCountForUser;
+      row.hasAcceptedInvitation = Boolean(groupedRow.hasAcceptedInvitation);
+    }
+
+    return rows;
+  }
+
+  /**
+   * Alphabetical by display name, case-insensitively. Rows with no name at all
+   * sort last so the list does not open on a run of blanks.
+   *
+   * Returns a new array; the input is left alone.
+   */
+  public static sortRowsByUserName(
+    rows: Array<ProjectUserRow>,
+  ): Array<ProjectUserRow> {
+    return [...rows].sort((a: ProjectUserRow, b: ProjectUserRow) => {
+      const nameA: string = this.getDisplayName(a).toLowerCase();
+      const nameB: string = this.getDisplayName(b).toLowerCase();
+
+      if (!nameA && !nameB) {
+        return 0;
+      }
+
+      if (!nameA) {
+        return 1;
+      }
+
+      if (!nameB) {
+        return -1;
+      }
+
+      return nameA.localeCompare(nameB);
+    });
+  }
+
+  private static addMembershipToRow(
+    row: ProjectUserRow,
+    teamMember: TeamMember,
+    teamKeys: Set<string>,
+    hasAcceptedInvitation: boolean,
+  ): void {
+    if (hasAcceptedInvitation) {
+      row.hasAcceptedInvitation = true;
+    } else {
+      row.pendingTeamCountForUser = row.pendingTeamCountForUser + 1;
+    }
+
+    const team: Team | undefined = teamMember.team;
+
+    if (!team) {
+      return;
+    }
+
+    const teamKey: string =
+      teamMember.teamId?.toString() ||
+      team._id?.toString() ||
+      team.name?.toString() ||
+      "";
+
+    if (!teamKey || teamKeys.has(teamKey)) {
+      return;
+    }
+
+    teamKeys.add(teamKey);
+    row.teamsForUser.push(team);
+  }
+
+  private static rememberMembershipId(
+    membershipIds: Array<string>,
+    teamMember: TeamMember,
+  ): void {
+    const membershipId: string = teamMember._id?.toString() || "";
+
+    if (membershipId) {
+      membershipIds.push(membershipId);
+    }
+  }
+
+  private static finalizeRow(
+    row: ProjectUserRow,
+    membershipIds: Array<string>,
+  ): void {
+    row.teamsForUser.sort((a: Team, b: Team) => {
+      return (a.name?.toString() || "")
+        .toLowerCase()
+        .localeCompare((b.name?.toString() || "").toLowerCase());
+    });
+
+    row.teamCountForUser = row.teamsForUser.length;
+
+    /*
+     * The row's id has to identify the *person*, not "whichever of their
+     * memberships was returned first". The table matches a selected row to an
+     * on-screen row by _id, and it fetches the on-screen page and the
+     * select-all set with two different sorts - so a first-seen id makes the
+     * same person carry different ids in the two results, and every
+     * multi-team user's checkbox silently fails to tick. The lowest membership
+     * id is stable under any ordering the server returns.
+     */
+    if (membershipIds.length > 1) {
+      row._id = [...membershipIds].sort()[0]!;
+    }
+  }
+}