Add Groups to Administration

A group is a shared address and mailbox and the people who share it. To
Stalwart it is an x:Account of type Group, behind the same sysAccount*
permissions as a person, so it sits under Directory beside Accounts:
search, a page of fifty with each group's member count, and a panel to
create, edit and delete one.

Membership lives on the member, not the group. Members are the users whose
memberGroupIds name it, and adding or removing one is a single
memberGroupIds/<group> pointer on that user's account -- true or null --
which leaves their other groups alone. Changes apply straight away rather
than riding on Save, so the list is always what the server has. Nobody can
add or remove themselves, the same line the account panel draws at one's
own role.

A group's role is Default or Custom, not a person's User or Admin, and it
is what the group may do: in 0.16 a user's permissions come from their own
roles only, and a group gives its members what is shared with it. Only
roles the viewer could grant are offered.

Delete takes the members out first and then deletes the group, the order
a domain's keys go before the domain, because the registry keeps anything
another object names. A role that cannot change the members' accounts is
not offered a delete it could only half finish.

The mock's groups had a person's roles, accepted a memberGroupIds filter
without applying it, and answered a linked delete with the wrong shape;
all three follow the source now, and it refuses nested groups and
memberships of things that are not groups.

Nothing about groups has been run against a live server yet: production
has none, and every operation is a write. KNOWN-ISSUES says what was read
from source.

Thirty-five new strings, two of them plurals, in all nine catalogues.

web/src/lib/__tests__/adminAccess.test.ts

@@ -13,7 +13,8 @@ const roles = new Map<string, RoleDef>([
 
 describe("who is offered administration", () => {
   it("needs both halves of reading the account list to list accounts", () => {
-    expect(adminSections(set("sysAccountQuery", "sysAccountGet"))).toEqual(["dashboard", "accounts"]);
+    // Groups are accounts to the server, so they come with the same two permissions.
+    expect(adminSections(set("sysAccountQuery", "sysAccountGet"))).toEqual(["dashboard", "accounts", "groups"]);
     // A query alone is a count on the dashboard, not a list.
     expect(adminSections(set("sysAccountQuery"))).toEqual(["dashboard"]);
     expect(hasAdministration(set("sysAccountGet"))).toBe(false);
@@ -23,7 +24,7 @@ describe("who is offered administration", () => {
   it("offers each section only with both halves of reading it", () => {
     expect(adminSections(set("sysDomainQuery", "sysDomainGet"))).toEqual(["dashboard", "domains"]);
     expect(hasAdministration(set("sysDomainQuery", "sysDomainGet"))).toBe(true);
-    expect(adminSections(set("sysAccountQuery", "sysAccountGet", "sysDomainQuery"))).toEqual(["dashboard", "accounts"]);
+    expect(adminSections(set("sysAccountQuery", "sysAccountGet", "sysDomainQuery"))).toEqual(["dashboard", "accounts", "groups"]);
   });
 
   it("gives the dashboard a card for each number the role can read", () => {

web/src/lib/__tests__/adminGroups.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it, vi } from "vitest";
+import { client } from "@/jmap/client";
+import { countMembers, createGroup, destroyGroup, groupRoleKey, groupRolesFromKey, membershipPatch } from "@/lib/adminGroups";
+
+describe("group membership", () => {
+  it("is a patch to each member, one pointer each, so no other membership moves", () => {
+    // Stalwart's set patch adds a key on `true` and removes it on `null`, and
+    // leaves every other key in the set as it was.
+    expect(membershipPatch(["u1", "u2"], "g1", true)).toEqual({ u1: { "memberGroupIds/g1": true }, u2: { "memberGroupIds/g1": true } });
+    expect(membershipPatch(["u1"], "g1", false)).toEqual({ u1: { "memberGroupIds/g1": null } });
+  });
+
+  it("counts members as users whose memberships name the group, asking for no ids", async () => {
+    const call = vi.spyOn(client, "call").mockResolvedValue({ ids: [], total: 4 });
+    expect(await countMembers(["g1"])).toEqual(new Map([["g1", 4]]));
+    expect(call).toHaveBeenCalledWith("x:Account/query", { filter: { "@type": "User", memberGroupIds: "g1" }, limit: 0, calculateTotal: true });
+    call.mockRestore();
+  });
+
+  it("leaves a count out rather than showing a failed one as none", async () => {
+    const call = vi.spyOn(client, "call").mockRejectedValue(new Error("offline"));
+    expect(await countMembers(["g1"])).toEqual(new Map());
+    call.mockRestore();
+  });
+});
+
+describe("creating and deleting a group", () => {
+  it("creates an account of type Group, with nothing a person needs to sign in", async () => {
+    const call = vi.spyOn(client, "call").mockResolvedValue({ created: { n: { id: "g9" } } });
+    expect(await createGroup({ name: " sales ", domainId: "d1", description: "", roles: { "@type": "Default" }, diskQuotaBytes: null })).toBe("g9");
+    const create = (call.mock.calls[0]![1] as { create: { n: Record<string, unknown> } }).create.n;
+    expect(create).toMatchObject({ "@type": "Group", name: "sales", domainId: "d1", description: null, roles: { "@type": "Default" }, permissions: { "@type": "Inherit" }, quotas: {} });
+    expect(create).not.toHaveProperty("credentials");
+    expect(create).not.toHaveProperty("encryptionAtRest");
+    expect(create).not.toHaveProperty("memberGroupIds");
+    call.mockRestore();
+  });
+
+  it("takes the members out before deleting, and deletes nothing if that fails", async () => {
+    const call = vi.spyOn(client, "call").mockResolvedValueOnce({ updated: { u1: null } }).mockResolvedValueOnce({ destroyed: ["g1"] });
+    await destroyGroup("g1", ["u1"]);
+    expect(call.mock.calls.map((c) => [c[0], Object.keys(c[1] as object)])).toEqual([
+      ["x:Account/set", ["update"]],
+      ["x:Account/set", ["destroy"]],
+    ]);
+    call.mockReset();
+    call.mockResolvedValueOnce({ notUpdated: { u1: { type: "forbidden" } } });
+    await expect(destroyGroup("g1", ["u1"])).rejects.toMatchObject({ type: "forbidden" });
+    expect(call).toHaveBeenCalledTimes(1);
+    call.mockRestore();
+  });
+
+  it("goes straight to the delete for a group with no members", async () => {
+    const call = vi.spyOn(client, "call").mockResolvedValue({ destroyed: ["g1"] });
+    await destroyGroup("g1", []);
+    expect(call).toHaveBeenCalledTimes(1);
+    expect(call).toHaveBeenCalledWith("x:Account/set", { destroy: ["g1"] });
+    call.mockRestore();
+  });
+
+  it("round-trips a group's roles, which are Default or Custom", () => {
+    for (const roles of [{ "@type": "Default" } as const, { "@type": "Custom", roleIds: { r1: true, r2: true } } as const]) {
+      expect(groupRolesFromKey(groupRoleKey(roles))).toEqual(roles);
+    }
+  });
+});