@nymphjs/tilmeld 1.0.0-beta.10 → 1.0.0-beta.100

package/src/User.ts

@@ -1,49 +1,87 @@
-import {
+import crypto from 'node:crypto';
+import type {
+  Nymph,
   EntityData,
   EntityJson,
   EntityPatch,
   Selector,
   SerializedEntityData,
 } from '@nymphjs/nymph';
-import { EmailOptions } from 'email-templates';
-import strtotime from 'locutus/php/datetime/strtotime';
-import Base64 from 'crypto-js/enc-base64';
-import sha256 from 'crypto-js/sha256';
-import md5 from 'crypto-js/md5';
-import { difference } from 'lodash';
 import { humanSecret, nanoid } from '@nymphjs/guid';
-
-import type Tilmeld from './Tilmeld';
-import AbleObject from './AbleObject';
-import Group, { GroupData } from './Group';
+import type { EmailOptions } from 'email-templates';
+import strtotime from 'locutus/php/datetime/strtotime.js';
+import { difference, xor } from 'lodash-es';
+import { TOTP, Secret } from 'otpauth';
+import { toDataURL } from 'qrcode';
+import { splitn } from '@sciactive/splitn';
+
+import { enforceTilmeld } from './enforceTilmeld.js';
+import AbleObject from './AbleObject.js';
+import GroupClass from './Group.js';
+import type { GroupData } from './Group.js';
 import {
+  AccessControlError,
   BadDataError,
   BadEmailError,
   BadUsernameError,
   EmailChangeRateLimitExceededError,
-} from './errors';
+} from './errors/index.js';
 
 export type EventType =
+  | 'checkUsername'
   | 'beforeRegister'
   | 'afterRegister'
+  | 'beforeSave'
+  | 'afterSave'
   | 'beforeLogin'
   | 'afterLogin'
   | 'beforeLogout'
-  | 'afterLogout';
+  | 'afterLogout'
+  | 'beforeDelete'
+  | 'afterDelete';
+/**
+ * This is run when the user has entered an otherwise valid username into the
+ * signup form. It should return a result, which when false will stop the
+ * process and return the included message, disallowing the username.
+ */
+export type TilmeldCheckUsernameCallback = (
+  user: User & UserData,
+  data: { username: string },
+) => Promise<{ result: boolean; message?: string }>;
 /**
- * Theses are run before the user data checks, so the only checks before are
+ * This is run before the user data checks, so the only checks before are
  * whether registration is allowed and whether the user is already registered.
  */
 export type TilmeldBeforeRegisterCallback = (
   user: User & UserData,
-  data: { password: string; additionalData?: { [k: string]: any } }
+  data: { password: string; additionalData?: { [k: string]: any } },
 ) => Promise<void>;
+/**
+ * This is run before the transaction is committed, and you can perform
+ * additional functions on the transaction, which is available in `user.$nymph`.
+ */
 export type TilmeldAfterRegisterCallback = (
   user: User & UserData,
-  result: { loggedin: boolean; message: string }
+  result: { loggedin: boolean; message: string },
+) => Promise<void>;
+/**
+ * This is run just before the user is saved, so all checks have passed.
+ *
+ * The transaction is available in `user.$nymph`.
+ */
+export type TilmeldBeforeSaveCallback = (
+  user: User & UserData,
 ) => Promise<void>;
 /**
- * These are run after the authentication checks, but before the login action.
+ * This is run before the transaction is committed, and you can perform
+ * additional functions on the transaction, which is available in `user.$nymph`.
+ *
+ * This is run after a new email verification email has been sent, so throwing
+ * an error will cause confusion for the user if they've changed their email.
+ */
+export type TilmeldAfterSaveCallback = (user: User & UserData) => Promise<void>;
+/**
+ * This is run after the authentication checks, but before the login action.
  */
 export type TilmeldBeforeLoginCallback = (
   user: User & UserData,
@@ -51,20 +89,32 @@ export type TilmeldBeforeLoginCallback = (
     username: string;
     password: string;
     additionalData?: { [k: string]: any };
-  }
+  },
 ) => Promise<void>;
-/**
- * This is run before the transaction is committed, and you can perform
- * additional functions on the transaction, which is available in `user.$nymph`.
- */
 export type TilmeldAfterLoginCallback = (
-  user: User & UserData
+  user: User & UserData,
 ) => Promise<void>;
 export type TilmeldBeforeLogoutCallback = (
-  user: User & UserData
+  user: User & UserData,
 ) => Promise<void>;
 export type TilmeldAfterLogoutCallback = (
-  user: User & UserData
+  user: User & UserData,
+) => Promise<void>;
+/**
+ * This is run before the user is logged out (if the current user is being
+ * deleted).
+ *
+ * The transaction is available in `user.$nymph`.
+ */
+export type TilmeldBeforeDeleteCallback = (
+  user: User & UserData,
+) => Promise<void>;
+/**
+ * This is run before the transaction is committed, and you can perform
+ * additional functions on the transaction, which is available in `user.$nymph`.
+ */
+export type TilmeldAfterDeleteCallback = (
+  user: User & UserData,
 ) => Promise<void>;
 
 export type UserData = {
@@ -108,11 +158,11 @@ export type UserData = {
   /**
    * The user's primary group.
    */
-  group?: Group & GroupData;
+  group?: GroupClass & GroupData;
   /**
    * The user's secondary groups.
    */
-  groups?: (Group & GroupData)[];
+  groups?: (GroupClass & GroupData)[];
   /**
    * Whether the user should inherit the abilities of his groups.
    */
@@ -135,7 +185,8 @@ export type UserData = {
    */
   newEmailSecret?: string;
   /**
-   * The new email address.
+   * If the user has changed their email address, this is the new one, awaiting
+   * verification.
    */
   newEmailAddress?: string;
   /**
@@ -167,6 +218,15 @@ export type UserData = {
    * database.
    */
   passwordTemp?: string;
+  /**
+   * If set, this timestamp is the cutoff point for JWT issue dates. Any token
+   * issued before this date will not authenticate the user.
+   */
+  revokeTokenDate?: number;
+  /**
+   * Two factor auth secret.
+   */
+  totpSecret?: string;
 };
 
 /**
@@ -182,15 +242,19 @@ export default class User extends AbleObject<UserData> {
   /**
    * The instance of Tilmeld to use for queries.
    */
-  static tilmeld: Tilmeld;
   static ETYPE = 'tilmeld_user';
   static class = 'User';
+  private static checkUsernameCallbacks: TilmeldCheckUsernameCallback[] = [];
   private static beforeRegisterCallbacks: TilmeldBeforeRegisterCallback[] = [];
   private static afterRegisterCallbacks: TilmeldAfterRegisterCallback[] = [];
+  private static beforeSaveCallbacks: TilmeldBeforeSaveCallback[] = [];
+  private static afterSaveCallbacks: TilmeldAfterSaveCallback[] = [];
   private static beforeLoginCallbacks: TilmeldBeforeLoginCallback[] = [];
   private static afterLoginCallbacks: TilmeldAfterLoginCallback[] = [];
   private static beforeLogoutCallbacks: TilmeldBeforeLogoutCallback[] = [];
   private static afterLogoutCallbacks: TilmeldAfterLogoutCallback[] = [];
+  private static beforeDeleteCallbacks: TilmeldBeforeDeleteCallback[] = [];
+  private static afterDeleteCallbacks: TilmeldAfterDeleteCallback[] = [];
 
   private static DEFAULT_CLIENT_ENABLED_METHODS = [
     '$checkUsername',
@@ -200,23 +264,33 @@ export default class User extends AbleObject<UserData> {
     '$register',
   ];
   private static DEFAULT_PRIVATE_DATA = [
+    // The things that are commented are there to show what is _not_ private.
+    'abilities',
+    // 'username',
+    // 'nameFirst',
+    // 'nameMiddle',
+    // 'nameLast',
+    // 'name',
     'email',
-    'originalEmail',
+    // 'avatar',
     'phone',
     'group',
     'groups',
-    'abilities',
     'inheritAbilities',
-    'recoverSecret',
-    'recoverSecretDate',
-    'password',
-    'salt',
+    'enabled',
     'secret',
-    'newEmailAddress',
+    'emailChangeDate',
     'newEmailSecret',
-    'cancelEmailAddress',
+    'newEmailAddress',
     'cancelEmailSecret',
-    'emailChangeDate',
+    'cancelEmailAddress',
+    'recoverSecret',
+    'recoverSecretDate',
+    'salt',
+    'password',
+    'passwordTemp',
+    'revokeTokenDate',
+    'totpSecret',
   ];
   private static DEFAULT_ALLOWLIST_DATA: string[] = [];
 
@@ -227,6 +301,7 @@ export default class User extends AbleObject<UserData> {
     'sendRecovery',
     'recover',
     'getClientConfig',
+    'getDomainUsers',
   ];
   protected $privateData = [...User.DEFAULT_PRIVATE_DATA];
   public static searchRestrictedData = [...User.DEFAULT_PRIVATE_DATA];
@@ -241,13 +316,17 @@ export default class User extends AbleObject<UserData> {
    */
   private $gatekeeperCache?: { [k: string]: true };
   /**
-   * This is explicitly used only during the registration proccess.
+   * This should only be used by the backend.
    */
   private $skipAcWhenSaving = false;
+  /**
+   * This should only be used by the backend.
+   */
+  private $skipAcWhenDeleting = false;
   /**
    * The user's group descendants.
    */
-  private $descendantGroups?: (Group & GroupData)[];
+  private $descendantGroups?: (GroupClass & GroupData)[];
   /**
    * Used to save the current email address to send verification if it changes
    * from the frontend.
@@ -256,10 +335,10 @@ export default class User extends AbleObject<UserData> {
    * verification, don't set this.
    */
   public $originalEmail?: string;
-
-  static async factory(guid?: string): Promise<User & UserData> {
-    return (await super.factory(guid)) as User & UserData;
-  }
+  /**
+   * Used to save the current username for domain admin permissions.
+   */
+  public $originalUsername?: string;
 
   static async factoryUsername(username?: string): Promise<User & UserData> {
     const entity = new this();
@@ -271,7 +350,7 @@ export default class User extends AbleObject<UserData> {
         {
           type: '&',
           ilike: ['username', username.replace(/([\\%_])/g, (s) => `\\${s}`)],
-        }
+        },
       );
       if (entity != null) {
         return entity;
@@ -280,34 +359,18 @@ export default class User extends AbleObject<UserData> {
     return entity;
   }
 
-  static factorySync(guid?: string): User & UserData {
-    return super.factorySync(guid) as User & UserData;
-  }
-
-  constructor(guid?: string) {
-    super(guid);
-
-    if (this.guid == null) {
-      // Defaults.
-      this.$data.enabled = true;
-      this.$data.abilities = [];
-      this.$data.groups = [];
-      this.$data.inheritAbilities = true;
-      this.$updateDataProtection();
-    }
-  }
-
   public static current(returnObjectIfNotExist: true): User & UserData;
   public static current(
-    returnObjectIfNotExist?: false
+    returnObjectIfNotExist?: false,
   ): (User & UserData) | null;
   public static current(
-    returnObjectIfNotExist?: boolean
+    returnObjectIfNotExist?: boolean,
   ): (User & UserData) | null {
-    if (this.tilmeld.currentUser == null) {
+    const tilmeld = enforceTilmeld(this);
+    if (tilmeld.currentUser == null) {
       return returnObjectIfNotExist ? this.factorySync() : null;
     }
-    return this.tilmeld.currentUser;
+    return tilmeld.currentUser;
   }
 
   /**
@@ -320,7 +383,8 @@ export default class User extends AbleObject<UserData> {
     recoveryType: 'username' | 'password';
     account: string;
   }): Promise<{ result: boolean; message: string }> {
-    if (!this.tilmeld.config.pwRecovery) {
+    const tilmeld = enforceTilmeld(this);
+    if (!tilmeld.config.pwRecovery) {
       return {
         result: false,
         message: 'Account recovery is not allowed.',
@@ -330,18 +394,15 @@ export default class User extends AbleObject<UserData> {
     let user: User & UserData;
     const options: EmailOptions = {};
 
-    if (
-      !this.tilmeld.config.emailUsernames &&
-      data.recoveryType === 'username'
-    ) {
+    if (!tilmeld.config.emailUsernames && data.recoveryType === 'username') {
       // Create a username recovery email.
 
       const getUser = await this.nymph.getEntity(
-        { class: this.tilmeld.User, skipAc: true },
+        { class: tilmeld.User, skipAc: true },
         {
           type: '&',
           ilike: ['email', data.account.replace(/([\\%_])/g, (s) => `\\${s}`)],
-        }
+        },
       );
 
       if (getUser == null) {
@@ -364,7 +425,7 @@ export default class User extends AbleObject<UserData> {
     } else if (data.recoveryType === 'password') {
       // Create a password recovery email.
 
-      const getUser = await this.tilmeld.User.factoryUsername(data.account);
+      const getUser = await tilmeld.User.factoryUsername(data.account);
 
       if (getUser.guid == null) {
         return {
@@ -391,14 +452,19 @@ export default class User extends AbleObject<UserData> {
       };
       options.locals = {
         recoverCode: getUser.recoverSecret,
-        timeLimit: this.tilmeld.config.pwRecoveryTimeLimit,
+        timeLimit: tilmeld.config.pwRecoveryTimeLimit,
       };
     } else {
       return { result: false, message: 'Invalid recovery type.' };
     }
 
+    this.nymph.config.debugLog(
+      'tilmeld',
+      `User account recovery (${options.template}) request for "${user.username}".`,
+    );
+
     // Send the email.
-    if (await this.tilmeld.config.sendEmail(this.tilmeld, options, user)) {
+    if (await tilmeld.config.sendEmail(tilmeld, options, user)) {
       return {
         result: true,
         message:
@@ -421,22 +487,23 @@ export default class User extends AbleObject<UserData> {
     secret: string;
     password: string;
   }): Promise<{ result: boolean; message: string }> {
-    if (!this.tilmeld.config.pwRecovery) {
+    const tilmeld = enforceTilmeld(this);
+    if (!tilmeld.config.pwRecovery) {
       return {
         result: false,
         message: 'Account recovery is not allowed.',
       };
     }
 
-    const user = await this.tilmeld.User.factoryUsername(data.username);
+    const user = await tilmeld.User.factoryUsername(data.username);
 
     if (
       user.guid == null ||
       user.recoverSecret == null ||
       data.secret !== user.recoverSecret ||
       strtotime(
-        '+' + this.tilmeld.config.pwRecoveryTimeLimit,
-        Math.floor((user.recoverSecretDate ?? 0) / 1000)
+        '+' + tilmeld.config.pwRecoveryTimeLimit,
+        Math.floor((user.recoverSecretDate ?? 0) / 1000),
       ) *
         1000 <
         Date.now()
@@ -451,6 +518,11 @@ export default class User extends AbleObject<UserData> {
       return { result: false, message: 'Password cannot be empty.' };
     }
 
+    this.nymph.config.debugLog(
+      'tilmeld',
+      `User account recovery for "${user.username}".`,
+    );
+
     user.$password(data.password);
     delete user.recoverSecret;
     delete user.recoverSecretDate;
@@ -466,27 +538,31 @@ export default class User extends AbleObject<UserData> {
   }
 
   public static getClientConfig() {
+    const tilmeld = enforceTilmeld(this);
     return {
-      regFields: this.tilmeld.config.regFields,
-      userFields: this.tilmeld.config.userFields,
-      emailUsernames: this.tilmeld.config.emailUsernames,
-      allowRegistration: this.tilmeld.config.allowRegistration,
-      allowUsernameChange: this.tilmeld.config.allowUsernameChange,
-      pwRecovery: this.tilmeld.config.pwRecovery,
-      verifyEmail: this.tilmeld.config.verifyEmail,
-      unverifiedAccess: this.tilmeld.config.unverifiedAccess,
+      regFields: tilmeld.config.regFields,
+      userFields: tilmeld.config.userFields,
+      emailUsernames: tilmeld.config.emailUsernames,
+      domainSupport: tilmeld.config.domainSupport,
+      allowRegistration: tilmeld.config.allowRegistration,
+      allowUsernameChange: tilmeld.config.allowUsernameChange,
+      pwRecovery: tilmeld.config.pwRecovery,
+      verifyEmail: tilmeld.config.verifyEmail,
+      unverifiedAccess: tilmeld.config.unverifiedAccess,
     };
   }
 
   public static async loginUser(data: {
     username: string;
     password: string;
+    code?: string;
     additionalData?: { [k: string]: any };
   }) {
+    const tilmeld = enforceTilmeld(this);
     if (!('username' in data) || !data.username.length) {
       return { result: false, message: 'Incorrect login/password.' };
     }
-    const user = await this.tilmeld.User.factoryUsername(data.username);
+    const user = await tilmeld.User.factoryUsername(data.username);
     const result: { result: boolean; message: string; user?: User & UserData } =
       await user.$login(data);
     if (result.result) {
@@ -496,23 +572,150 @@ export default class User extends AbleObject<UserData> {
     return result;
   }
 
+  /**
+   * Get the users in a domain. This is only accessible to the domain's admins.
+   */
+  public static async getDomainUsers(
+    domain: string,
+    options?: {
+      limit?: number;
+      offset?: number;
+      sort?: string;
+      reverse?: boolean;
+    },
+  ) {
+    const tilmeld = enforceTilmeld(this);
+
+    if (!tilmeld.config.domainSupport) {
+      throw new AccessControlError('Domain support is not enabled.');
+    }
+
+    if (!domain) {
+      throw new BadDataError('Domain is required.');
+    }
+
+    domain = domain.toLowerCase();
+    if (!tilmeld.config.validDomainRegex.test(domain)) {
+      throw new BadDataError(tilmeld.config.validDomainRegexNotice);
+    }
+
+    if (!tilmeld.gatekeeper(`tilmeld/domain/${domain}/admin`)) {
+      throw new AccessControlError(
+        'You do not have the authority to manage this domain.',
+      );
+    }
+
+    return await this.nymph.getEntities(
+      {
+        class: this.nymph.getEntityClass(User),
+        ...(options?.limit != null
+          ? {
+              limit: options.limit,
+            }
+          : {}),
+        ...(options?.offset != null
+          ? {
+              offset: options.offset,
+            }
+          : {}),
+        ...(options?.sort != null
+          ? {
+              sort: options.sort,
+            }
+          : {}),
+        ...(options?.reverse != null
+          ? {
+              reverse: options.reverse,
+            }
+          : {}),
+      },
+      {
+        type: '&',
+        like: ['username', `%@${domain.replace(/([\\%_])/g, (s) => `\\${s}`)}`],
+      },
+    );
+  }
+
+  constructor() {
+    super();
+
+    // Defaults.
+    this.$data.enabled = true;
+    this.$data.abilities = [];
+    this.$data.groups = [];
+    this.$data.inheritAbilities = true;
+    this.$updateDataProtection();
+  }
+
+  $setNymph(nymph: Nymph) {
+    this.$nymph = nymph;
+    if (!this.$asleep()) {
+      if (this.$data.group && this.$data.group.$nymph !== nymph) {
+        this.$data.group.$setNymph(nymph);
+      }
+      for (const group of this.$data.groups ?? []) {
+        if (group && group.$nymph !== nymph) {
+          group.$setNymph(nymph);
+        }
+      }
+    }
+  }
+
+  async $getUniques(): Promise<string[]> {
+    const tilmeld = enforceTilmeld(this);
+    const uniques = [`u:${this.$data.username}`];
+    if (
+      !tilmeld.config.emailUsernames &&
+      tilmeld.config.userFields.includes('email')
+    ) {
+      uniques.push(`e:${this.$data.email}`);
+
+      if (this.$data.newEmailAddress != null) {
+        uniques.push(`e:${this.$data.newEmailAddress}`);
+      }
+    }
+    return uniques;
+  }
+
   public async $login(data: {
     username: string;
     password: string;
+    code?: string;
     additionalData?: { [k: string]: any };
   }) {
-    const tilmeld = this.$nymph.tilmeld as Tilmeld;
+    const tilmeld = enforceTilmeld(this);
     if (this.guid == null) {
+      await tilmeld.config.failedLoginAttempt(null, data);
+      return { result: false, message: 'Incorrect login/password.' };
+    }
+    if (!this.$checkPassword(data.password)) {
+      await tilmeld.config.failedLoginAttempt(this, data);
       return { result: false, message: 'Incorrect login/password.' };
     }
     if (!this.$data.enabled) {
-      return { result: false, message: 'This user is disabled.' };
+      return { result: false, message: 'Your account is disabled.' };
     }
-    if (this.$gatekeeper()) {
+    if (await this.$gatekeeper()) {
       return { result: true, message: 'You are already logged in.' };
     }
-    if (!this.$checkPassword(data.password)) {
-      return { result: false, message: 'Incorrect login/password.' };
+
+    if (this.$data.totpSecret != null) {
+      if (
+        data.code == null ||
+        typeof data.code !== 'string' ||
+        data.code.length !== 6
+      ) {
+        return {
+          result: false,
+          needTOTP: true,
+          message: 'You need to provide a 2FA code.',
+        };
+      }
+
+      if (!this.$checkTOTPCode(data.code)) {
+        await tilmeld.config.failedLoginAttempt(this, data);
+        return { result: false, message: 'Incorrect 2FA code.' };
+      }
     }
 
     try {
@@ -529,8 +732,90 @@ export default class User extends AbleObject<UserData> {
       };
     }
 
+    this.$nymph.config.debugLog(
+      'tilmeld',
+      `User login for "${this.$data.username}".`,
+    );
+
+    // Authentication was successful, attempt to login.
+    if (!(await tilmeld.login(this, true))) {
+      return { result: false, message: 'Incorrect login/password.' };
+    }
+
+    for (let callback of (this.constructor as typeof User)
+      .afterLoginCallbacks) {
+      if (callback) {
+        await callback(this);
+      }
+    }
+
+    // Login was successful.
+    return { result: true, message: 'You are logged in.' };
+  }
+
+  public async $switchUser(data?: { additionalData?: { [k: string]: any } }) {
+    const tilmeld = enforceTilmeld(this);
+    if (this.guid == null) {
+      return { result: false, message: 'Incorrect login/password.' };
+    }
+
+    let user = tilmeld.User.current();
+
+    if (!user || user.guid == null) {
+      return { result: false, message: "You're not logged in." };
+    }
+
+    const isCurrentUser = user != null && user.$is(this);
+
+    if (isCurrentUser) {
+      return { result: false, message: "You can't switch to yourself." };
+    }
+
+    const toAbilities = this.$data.abilities || [];
+    const fromAbilities = user.abilities || [];
+
+    if (
+      !fromAbilities.includes('tilmeld/switch') &&
+      !fromAbilities.includes('system/admin')
+    ) {
+      return {
+        result: false,
+        message: "You don't have permission to switch users.",
+      };
+    }
+
+    if (
+      toAbilities.includes('system/admin') ||
+      toAbilities.includes('tilmeld/admin')
+    ) {
+      return { result: false, message: "You can't switch to an admin." };
+    }
+
+    try {
+      for (let callback of (this.constructor as typeof User)
+        .beforeLoginCallbacks) {
+        if (callback) {
+          await callback(this, {
+            username: this.$data.username || '',
+            password: '',
+            ...(data || {}),
+          });
+        }
+      }
+    } catch (e: any) {
+      return {
+        result: false,
+        message: e.message,
+      };
+    }
+
+    this.$nymph.config.debugLog(
+      'tilmeld',
+      `User login switch for "${user.username}" to "${this.$data.username}".`,
+    );
+
     // Authentication was successful, attempt to login.
-    if (!tilmeld.login(this, true)) {
+    if (!(await tilmeld.loginSwitch(this, true))) {
       return { result: false, message: 'Incorrect login/password.' };
     }
 
@@ -550,7 +835,7 @@ export default class User extends AbleObject<UserData> {
    * @returns An object with a boolean 'result' entry and a 'message' entry.
    */
   public async $logout() {
-    const tilmeld = this.$nymph.tilmeld as Tilmeld;
+    const tilmeld = enforceTilmeld(this);
 
     try {
       for (let callback of (this.constructor as typeof User)
@@ -566,7 +851,12 @@ export default class User extends AbleObject<UserData> {
       };
     }
 
-    tilmeld.logout();
+    this.$nymph.config.debugLog(
+      'tilmeld',
+      `User logout for "${this.$data.username}".`,
+    );
+
+    await tilmeld.logout();
 
     for (let callback of (this.constructor as typeof User)
       .afterLogoutCallbacks) {
@@ -587,89 +877,176 @@ export default class User extends AbleObject<UserData> {
     }
     return (
       'https://secure.gravatar.com/avatar/' +
-      md5(this.$data.email.trim().toLowerCase()).toString() +
+      crypto
+        .createHash('sha256')
+        .update(this.$data.email.trim().toLowerCase())
+        .digest('hex')
+        .toLowerCase() +
       '?d=identicon&s=40'
     );
   }
 
+  public $getGid() {
+    if (this.$data.group) {
+      return this.$data.group.guid;
+    }
+    return null;
+  }
+
+  public $getGids() {
+    if (this.$data.groups) {
+      return this.$data.groups
+        .map((group) => group.guid)
+        .filter((guid) => guid != null) as string[];
+    }
+    return null;
+  }
+
   /**
    * Get the user's group descendants.
    */
-  public async $getDescendantGroups(): Promise<(Group & GroupData)[]> {
+  public async $getDescendantGroups(): Promise<(GroupClass & GroupData)[]> {
     if (this.$descendantGroups == null) {
       this.$descendantGroups = [];
       if (this.$data.group != null) {
+        await this.$data.group.$wake();
         this.$descendantGroups = await this.$data.group.$getDescendants();
       }
+      await Promise.all(this.$data.groups?.map((e) => e.$wake()) || []);
       for (let curGroup of this.$data.groups ?? []) {
         this.$descendantGroups = this.$descendantGroups?.concat(
-          await curGroup.$getDescendants()
+          await curGroup.$getDescendants(),
         );
       }
     }
     return this.$descendantGroups;
   }
 
-  /**
-   * Get the user's group descendants.
-   */
-  public $getDescendantGroupsSync(): (Group & GroupData)[] {
-    if (this.$descendantGroups == null) {
-      this.$descendantGroups = [];
-      if (this.$data.group != null) {
-        this.$descendantGroups = this.$data.group.$getDescendantsSync();
-      }
-      for (let curGroup of this.$data.groups ?? []) {
-        this.$descendantGroups = this.$descendantGroups?.concat(
-          curGroup.$getDescendantsSync()
-        );
+  public $jsonAcceptData(input: EntityJson, allowConflict = false) {
+    const tilmeld = enforceTilmeld(this);
+    this.$check();
+
+    if ('abilities' in input.data) {
+      this.$checkIncomingAbilities(input.data.abilities);
+    }
+
+    // If the user is a new domain user, the data protection needs to be updated
+    // before the data is accepted, or else some things won't be accepted
+    // correctly (enabled, passwordTemp).
+    let reloadDataProtection = false;
+    if (tilmeld.config.domainSupport) {
+      let [_username, domain] = splitn(input.data.username ?? '', '@', 2);
+      // Lowercase the domain part.
+      if (domain) {
+        domain = domain.toLowerCase();
       }
+      const user = tilmeld.User.current();
+      const isCurrentUser = user != null && user.$is(this);
+      // While loading, accessing abilities on the current user will infinitely
+      // loop, but if this is the current user, we can use its abilities.
+      const abilities =
+        (isCurrentUser || user == null
+          ? this.$data.abilities
+          : user?.abilities) ?? [];
+      const isNewUser = input.guid == null;
+      const isDomainUser =
+        !isCurrentUser &&
+        user != null &&
+        domain &&
+        abilities.includes(`tilmeld/domain/${domain}/admin`);
+
+      reloadDataProtection = !!(isNewUser && isDomainUser);
+    }
+
+    super.$jsonAcceptData(input, allowConflict);
+
+    if (reloadDataProtection) {
+      // Load it again after data protection is run.
+      this.$updateDataProtection();
+      super.$jsonAcceptData(input, allowConflict);
     }
-    return this.$descendantGroups;
   }
 
-  public $jsonAcceptData(input: EntityJson, allowConflict = false) {
-    const tilmeld = this.$nymph.tilmeld as Tilmeld;
-    this.$referenceWake();
+  public $jsonAcceptPatch(patch: EntityPatch, allowConflict = false) {
+    this.$check();
+
+    if ('abilities' in patch.set) {
+      this.$checkIncomingAbilities(patch.set.abilities);
+    }
+
+    super.$jsonAcceptPatch(patch, allowConflict);
+  }
+
+  private $checkIncomingAbilities(incoming: any) {
+    const tilmeld = enforceTilmeld(this);
 
     if (
-      'abilities' in input.data &&
-      input.data.abilities.indexOf('system/admin') !== -1 &&
-      this.$data.abilities?.indexOf('system/admin') === -1 &&
-      tilmeld.gatekeeper('tilmeld/admin') &&
-      !tilmeld.gatekeeper('system/admin')
+      !Array.isArray(incoming) ||
+      incoming.find((ability) => typeof ability !== 'string')
+    ) {
+      throw new BadDataError('Abilities must be an array of strings.');
+    }
+
+    if (
+      incoming.includes('system/admin') !==
+        this.$data.abilities?.includes('system/admin') &&
+      (!tilmeld.currentUser ||
+        !tilmeld.currentUser.abilities?.includes('system/admin'))
     ) {
       throw new BadDataError(
-        "You don't have the authority to make this user a system admin."
+        "You don't have the authority to grant or revoke system/admin.",
       );
     }
 
-    this.$originalEmail = this.$data.email;
-    super.$jsonAcceptData(input, allowConflict);
-  }
-
-  public $jsonAcceptPatch(patch: EntityPatch, allowConflict = false) {
-    const tilmeld = this.$nymph.tilmeld as Tilmeld;
-    this.$referenceWake();
+    if (
+      incoming.includes('tilmeld/admin') !==
+        this.$data.abilities?.includes('tilmeld/admin') &&
+      (!tilmeld.currentUser ||
+        !tilmeld.currentUser.abilities?.includes('system/admin'))
+    ) {
+      throw new BadDataError(
+        "You don't have the authority to grant or revoke tilmeld/admin.",
+      );
+    }
 
     if (
-      'abilities' in patch.set &&
-      patch.set.abilities.indexOf('system/admin') !== -1 &&
-      this.$data.abilities?.indexOf('system/admin') === -1 &&
-      tilmeld.gatekeeper('tilmeld/admin') &&
-      !tilmeld.gatekeeper('system/admin')
+      incoming.includes('tilmeld/switch') !==
+        this.$data.abilities?.includes('tilmeld/switch') &&
+      (!tilmeld.currentUser ||
+        !tilmeld.currentUser.abilities?.includes('system/admin'))
     ) {
       throw new BadDataError(
-        "You don't have the authority to make this user a system admin."
+        "You don't have the authority to grant or revoke tilmeld/switch.",
       );
     }
 
-    this.$originalEmail = this.$data.email;
-    super.$jsonAcceptPatch(patch, allowConflict);
+    if (
+      xor(
+        incoming.filter((ability: string) => ability.startsWith('tilmeld/')),
+        this.$data.abilities?.filter((ability: string) =>
+          ability.startsWith('tilmeld/'),
+        ) ?? [],
+      ).length &&
+      (!tilmeld.currentUser ||
+        (!tilmeld.currentUser.abilities?.includes('system/admin') &&
+          !tilmeld.currentUser.abilities?.includes('tilmeld/admin')))
+    ) {
+      throw new BadDataError(
+        "You don't have the authority to grant or revoke Tilmeld abilities.",
+      );
+    }
   }
 
-  public $putData(data: EntityData, sdata?: SerializedEntityData) {
-    super.$putData(data, sdata);
+  public $putData(
+    data: EntityData,
+    sdata?: SerializedEntityData,
+    source?: 'server',
+  ) {
+    super.$putData(data, sdata, source);
+    if (source === 'server') {
+      this.$originalEmail = this.$data.email;
+      this.$originalUsername = this.$data.username;
+    }
     this.$updateDataProtection();
   }
 
@@ -679,8 +1056,15 @@ export default class User extends AbleObject<UserData> {
    * @param givenUser User to update protection for. If undefined, will use the currently logged in user.
    */
   public $updateDataProtection(givenUser?: User & UserData) {
-    const tilmeld = this.$nymph.tilmeld as Tilmeld;
+    const tilmeld = enforceTilmeld(this);
     let user = givenUser ?? tilmeld.User.current();
+    let [_username, domain] = tilmeld.config.domainSupport
+      ? splitn(this.$originalUsername ?? this.$data.username ?? '', '@', 2)
+      : [this.$originalUsername ?? this.$data.username, null];
+    // Lowercase the domain part.
+    if (domain) {
+      domain = domain.toLowerCase();
+    }
 
     this.$clientEnabledMethods = [...User.DEFAULT_CLIENT_ENABLED_METHODS];
     this.$privateData = [...User.DEFAULT_PRIVATE_DATA];
@@ -698,53 +1082,165 @@ export default class User extends AbleObject<UserData> {
         ? this.$data.abilities
         : user?.abilities) ?? [];
     const isNewUser = this.guid == null;
+    const isDomainUser =
+      tilmeld.config.domainSupport &&
+      !isCurrentUser &&
+      user != null &&
+      domain &&
+      abilities.includes(`tilmeld/domain/${domain}/admin`);
 
     if (isCurrentUser) {
       // Users can check to see what abilities they have.
       this.$clientEnabledMethods.push('$gatekeeper');
       this.$clientEnabledMethods.push('$changePassword');
+      this.$clientEnabledMethods.push('$revokeCurrentTokens');
       this.$clientEnabledMethods.push('$logout');
       this.$clientEnabledMethods.push('$sendEmailVerification');
+      this.$clientEnabledMethods.push('$hasTOTPSecret');
+      this.$clientEnabledMethods.push('$getNewTOTPSecret');
+      this.$clientEnabledMethods.push('$saveTOTPSecret');
+      this.$clientEnabledMethods.push('$removeTOTPSecret');
+    }
+
+    if (isDomainUser) {
+      // Domain admins can check to see what abilities their users have.
+      this.$clientEnabledMethods.push('$gatekeeper');
+      this.$clientEnabledMethods.push('$changePassword');
+      this.$clientEnabledMethods.push('$revokeCurrentTokens');
+      this.$clientEnabledMethods.push('$hasTOTPSecret');
+      this.$clientEnabledMethods.push('$getNewTOTPSecret');
+      this.$clientEnabledMethods.push('$saveTOTPSecret');
+      this.$clientEnabledMethods.push('$removeTOTPSecret');
     }
 
     if (
       user != null &&
-      (abilities.indexOf('tilmeld/admin') !== -1 ||
-        abilities.indexOf('system/admin') !== -1)
+      (abilities.includes('tilmeld/admin') ||
+        abilities.includes('system/admin'))
     ) {
       // Users who can edit other users can see most of their data.
-      this.$privateData = ['password', 'salt'];
+      this.$privateData = ['password', 'salt', 'totpSecret'];
+      this.$clientEnabledMethods.push('$hasTOTPSecret');
+      this.$clientEnabledMethods.push('$removeTOTPSecret');
       this.$allowlistData = undefined;
-    } else if (isCurrentUser || isNewUser) {
-      // Users can see their own data, and edit some of it.
+    } else if (isDomainUser) {
+      // Domain admins can see their users' data, and edit some of it.
       if (tilmeld.config.allowUsernameChange || isNewUser) {
         this.$allowlistData.push('username');
       }
       this.$allowlistData.push('avatar');
-      if (tilmeld.config.userFields.indexOf('name') !== -1) {
+      if (tilmeld.config.userFields.includes('name')) {
         this.$allowlistData.push('nameFirst');
         this.$allowlistData.push('nameMiddle');
         this.$allowlistData.push('nameLast');
         this.$allowlistData.push('name');
       }
-      if (tilmeld.config.userFields.indexOf('email') !== -1) {
+      if (tilmeld.config.userFields.includes('email')) {
         this.$allowlistData.push('email');
       }
-      if (tilmeld.config.userFields.indexOf('phone') !== -1) {
+      if (tilmeld.config.userFields.includes('phone')) {
         this.$allowlistData.push('phone');
       }
+      this.$allowlistData.push('enabled');
+      this.$allowlistData.push('passwordTemp');
       this.$privateData = [
+        // The things commented are there to show what is _not_ private.
+        // 'abilities',
+        // 'username',
+        // 'nameFirst',
+        // 'nameMiddle',
+        // 'nameLast',
+        // 'name',
+        // 'email',
+        // 'avatar',
+        // 'phone',
+        // 'group',
+        // 'groups',
+        // 'inheritAbilities',
+        // 'enabled',
         'secret',
+        'emailChangeDate',
         'newEmailSecret',
-        'cancelEmailAddress',
+        // 'newEmailAddress',
         'cancelEmailSecret',
-        'emailChangeDate',
+        'cancelEmailAddress',
         'recoverSecret',
         'recoverSecretDate',
+        'salt',
         'password',
+        // 'passwordTemp',
+        // 'revokeTokenDate',
+        'totpSecret',
+      ];
+    } else if (isCurrentUser || isNewUser) {
+      // Users can see their own data, and edit some of it.
+      if (tilmeld.config.allowUsernameChange || isNewUser) {
+        this.$allowlistData.push('username');
+      }
+      this.$allowlistData.push('avatar');
+      if (tilmeld.config.userFields.includes('name')) {
+        this.$allowlistData.push('nameFirst');
+        this.$allowlistData.push('nameMiddle');
+        this.$allowlistData.push('nameLast');
+        this.$allowlistData.push('name');
+      }
+      if (tilmeld.config.userFields.includes('email')) {
+        this.$allowlistData.push('email');
+      }
+      if (tilmeld.config.userFields.includes('phone')) {
+        this.$allowlistData.push('phone');
+      }
+      this.$privateData = [
+        // The things commented are there to show what is _not_ private.
+        // 'abilities',
+        // 'username',
+        // 'nameFirst',
+        // 'nameMiddle',
+        // 'nameLast',
+        // 'name',
+        // 'email',
+        // 'avatar',
+        // 'phone',
+        // 'group',
+        // 'groups',
+        // 'inheritAbilities',
+        'enabled',
+        'secret',
+        'emailChangeDate',
+        'newEmailSecret',
+        // 'newEmailAddress',
+        'cancelEmailSecret',
+        'cancelEmailAddress',
+        'recoverSecret',
+        'recoverSecretDate',
         'salt',
+        'password',
+        'passwordTemp',
+        // 'revokeTokenDate',
+        'totpSecret',
       ];
     }
+
+    if (
+      user != null &&
+      !isCurrentUser &&
+      (abilities.includes('tilmeld/switch') ||
+        abilities.includes('system/admin'))
+    ) {
+      // Users with this ability can switch to other users.
+      this.$clientEnabledMethods.push('$switchUser');
+    }
+  }
+
+  public $updateGroupDataProtection() {
+    if (this.$data.group != null && !this.$data.group.$asleep()) {
+      this.$data.group.$updateDataProtection();
+    }
+    for (let group of this.$data.groups ?? []) {
+      if (!group.$asleep()) {
+        group.$updateDataProtection();
+      }
+    }
   }
 
   /**
@@ -761,35 +1257,43 @@ export default class User extends AbleObject<UserData> {
    * @param ability The ability.
    * @returns True or false.
    */
-  public $gatekeeper(ability?: string): boolean {
-    const tilmeld = this.$nymph.tilmeld as Tilmeld;
+  public async $gatekeeper(ability?: string): Promise<boolean> {
+    await this.$wake();
+    const tilmeld = enforceTilmeld(this);
     if (ability == null) {
       return tilmeld.User.current()?.$is(this) ?? false;
     }
     // Check the cache to see if we've already checked this user.
     if (this.$gatekeeperCache == null) {
-      let abilities = this.$data.abilities ?? [];
-      if (this.$data.inheritAbilities) {
-        for (let curGroup of this.$data.groups ?? []) {
-          if (curGroup.enabled) {
-            abilities = abilities.concat(curGroup.abilities ?? []);
-          }
-        }
-        if (
-          this.$data.group != null &&
-          this.$data.group.cdate != null &&
-          this.$data.group.enabled
-        ) {
-          abilities = abilities.concat(this.$data.group.abilities ?? []);
-        }
-      }
-      this.$gatekeeperCache = Object.fromEntries(
-        abilities.map((ability) => [ability, true])
-      );
+      this.$gatekeeperCache = await this.$getGatekeeperCache();
     }
     return (
       (ability in this.$gatekeeperCache && !!this.$gatekeeperCache[ability]) ||
-      !!this.$gatekeeperCache['system/admin']
+      !!this.$data.abilities?.includes('system/admin')
+    );
+  }
+
+  /**
+   * Build a gatekeeper cache object.
+   */
+  public async $getGatekeeperCache() {
+    await this.$wake();
+    let abilities = this.$data.abilities ?? [];
+    if (this.$data.inheritAbilities) {
+      await Promise.all(this.$data.groups?.map((e) => e.$wake()) || []);
+      for (let curGroup of this.$data.groups ?? []) {
+        if (curGroup.enabled) {
+          abilities = abilities.concat(curGroup.abilities ?? []);
+        }
+      }
+      await this.$data.group?.$wake();
+      const group = this.$data.group;
+      if (group != null && group.cdate != null && group.enabled) {
+        abilities = abilities.concat(group.abilities ?? []);
+      }
+    }
+    return Object.fromEntries(
+      abilities.map((ability) => [ability, true as true]),
     );
   }
 
@@ -806,7 +1310,7 @@ export default class User extends AbleObject<UserData> {
    * @returns True on success, false on failure.
    */
   public async $sendEmailVerification() {
-    const tilmeld = this.$nymph.tilmeld as Tilmeld;
+    const tilmeld = enforceTilmeld(this);
     if (this.guid == null) {
       return false;
     }
@@ -818,7 +1322,7 @@ export default class User extends AbleObject<UserData> {
 
     if (this.$data.secret != null) {
       const link = `${verifyUrl}?action=verify&id=${encodeURIComponent(
-        this.guid
+        this.guid,
       )}&secret=${encodeURIComponent(this.$data.secret)}`;
       success =
         success &&
@@ -836,13 +1340,13 @@ export default class User extends AbleObject<UserData> {
               verifyLink: link,
             },
           },
-          this
+          this,
         ));
     }
 
     if (this.$data.newEmailSecret != null) {
       const link = `${verifyUrl}?action=verifychange&id=${encodeURIComponent(
-        this.guid
+        this.guid,
       )}&secret=${encodeURIComponent(this.$data.newEmailSecret)}`;
       success =
         success &&
@@ -862,13 +1366,13 @@ export default class User extends AbleObject<UserData> {
               newEmail: this.$data.newEmailAddress,
             },
           },
-          this
+          this,
         ));
     }
 
     if (this.$data.cancelEmailSecret != null) {
       const link = `${verifyUrl}?action=cancelchange&id=${encodeURIComponent(
-        this.guid
+        this.guid,
       )}&secret=${encodeURIComponent(this.$data.cancelEmailSecret)}`;
       success =
         success &&
@@ -888,7 +1392,7 @@ export default class User extends AbleObject<UserData> {
               newEmail: this.$data.newEmailAddress ?? this.$data.email,
             },
           },
-          this
+          this,
         ));
     }
 
@@ -901,13 +1405,16 @@ export default class User extends AbleObject<UserData> {
    * @param group The group.
    * @returns True if the user is already in the group. The resulting array of groups if the user was not.
    */
-  public $addGroup(group: Group & GroupData) {
-    if (this.$data.groups == null) {
-      this.$data.groups = [];
+  public async $addGroup(group: GroupClass & GroupData) {
+    await Promise.all(this.$data.groups?.map((e) => e.$wake()) || []);
+    let groups = this.$data.groups;
+    if (groups == null) {
+      groups = [];
     }
-    if (!group.$inArray(this.$data.groups)) {
-      this.$data.groups.push(group);
-      return this.$data.groups;
+    if (!group.$inArray(groups)) {
+      groups.push(group);
+      this.$data.groups = groups;
+      return groups;
     }
     return true;
   }
@@ -919,17 +1426,23 @@ export default class User extends AbleObject<UserData> {
    * @returns True if the passwords match, otherwise false.
    */
   public $checkPassword(password: string) {
-    const tilmeld = this.$nymph.tilmeld as Tilmeld;
+    const tilmeld = enforceTilmeld(this);
     switch (tilmeld.config.pwMethod) {
       case 'plain':
         return this.$data.password === password;
       case 'digest':
-        return this.$data.password === sha256(password).toString(Base64);
+        return (
+          this.$data.password ===
+          crypto.createHash('sha256').update(password).digest('base64')
+        );
       case 'salt':
       default:
         return (
           this.$data.password ===
-          sha256(password + this.$data.salt).toString(Base64)
+          crypto
+            .createHash('sha256')
+            .update(password + this.$data.salt)
+            .digest('base64')
         );
     }
   }
@@ -940,10 +1453,12 @@ export default class User extends AbleObject<UserData> {
    * @param group The group.
    * @returns True if the user wasn't in the group. The resulting array of groups if the user was.
    */
-  public $delGroup(group: Group & GroupData) {
-    if (this.$data.groups != null && group.$inArray(this.$data.groups)) {
-      const newGroups: (Group & GroupData)[] = [];
-      for (let curGroup of this.$data.groups) {
+  public async $delGroup(group: GroupClass & GroupData) {
+    await Promise.all(this.$data.groups?.map((e) => e.$wake()) || []);
+    let groups = this.$data.groups || [];
+    if (this.$data.groups != null && group.$inArray(groups)) {
+      const newGroups: (GroupClass & GroupData)[] = [];
+      for (let curGroup of groups) {
         if (!group.$is(curGroup)) {
           newGroups.push(curGroup);
         }
@@ -960,7 +1475,7 @@ export default class User extends AbleObject<UserData> {
    * @param group The group, or the group's GUID.
    * @returns True or false.
    */
-  public $inGroup(group: (Group & GroupData) | string) {
+  public async $inGroup(group: (GroupClass & GroupData) | string) {
     if (typeof group === 'string') {
       if (this.$data.group?.guid === group) {
         return true;
@@ -983,16 +1498,19 @@ export default class User extends AbleObject<UserData> {
    * @param group The group, or the group's GUID.
    * @returns True or false.
    */
-  public $isDescendant(group: (Group & GroupData) | string) {
+  public async $isDescendant(group: (GroupClass & GroupData) | string) {
     // Check to see if the user is in a descendant group of the given group.
+    await this.$data.group?.$wake();
     if (
+      this.$data.group != null &&
       this.$data.group?.cdate != null &&
-      this.$data.group.$isDescendant(group)
+      (await this.$data.group?.$isDescendant(group))
     ) {
       return true;
     }
+    await Promise.all(this.$data.groups?.map((e) => e.$wake()) || []);
     for (let curGroup of this.$data.groups ?? []) {
-      if (curGroup.$isDescendant(group)) {
+      if (await curGroup.$isDescendant(group)) {
         return true;
       }
     }
@@ -1008,15 +1526,31 @@ export default class User extends AbleObject<UserData> {
   public async $changePassword(data: {
     newPassword: string;
     currentPassword: string;
+    revokeCurrentTokens?: boolean;
   }): Promise<{ result: boolean; message: string }> {
+    this.$nymph.config.debugLog(
+      'tilmeld',
+      `Password change request for "${this.$data.username}".`,
+    );
     if (!('newPassword' in data) || !data.newPassword.length) {
       return { result: false, message: 'Please specify a password.' };
     }
     if (!this.$checkPassword(data.currentPassword ?? '')) {
+      this.$nymph.config.debugLog(
+        'tilmeld',
+        `Incorrect password for change request for "${this.$data.username}".`,
+      );
       return { result: false, message: 'Incorrect password.' };
     }
     this.$data.passwordTemp = data.newPassword;
+    if (data.revokeCurrentTokens) {
+      this.$data.revokeTokenDate = Date.now();
+    }
     if (await this.$save()) {
+      if (data.revokeCurrentTokens) {
+        const tilmeld = enforceTilmeld(this);
+        await tilmeld.login(this, true);
+      }
       return { result: true, message: 'Your password has been changed.' };
     } else {
       return { result: false, message: "Couldn't save new password." };
@@ -1030,7 +1564,7 @@ export default class User extends AbleObject<UserData> {
    * @returns The resulting password or hash which is stored in the entity.
    */
   public $password(password: string) {
-    const tilmeld = this.$nymph.tilmeld as Tilmeld;
+    const tilmeld = enforceTilmeld(this);
     switch (tilmeld.config.pwMethod) {
       case 'plain':
         delete this.$data.salt;
@@ -1038,34 +1572,275 @@ export default class User extends AbleObject<UserData> {
         break;
       case 'digest':
         delete this.$data.salt;
-        this.$data.password = sha256(password).toString(Base64);
+        this.$data.password = crypto
+          .createHash('sha256')
+          .update(password)
+          .digest('base64');
         break;
       case 'salt':
       default:
         this.$data.salt = nanoid();
-        this.$data.password = sha256(password + this.$data.salt).toString(
-          Base64
-        );
+        this.$data.password = crypto
+          .createHash('sha256')
+          .update(password + this.$data.salt)
+          .digest('base64');
         break;
     }
     return this.$data.password;
   }
 
+  /**
+   * A frontend accessible method to revoke all currently issued tokens.
+   *
+   * @param data The input data from the client.
+   * @returns An object with a boolean 'result' entry and a 'message' entry.
+   */
+  public async $revokeCurrentTokens(data: {
+    password: string;
+  }): Promise<{ result: boolean; message: string }> {
+    if (!this.$checkPassword(data.password ?? '')) {
+      return { result: false, message: 'Incorrect password.' };
+    }
+
+    this.$data.revokeTokenDate = Date.now();
+
+    if (await this.$save()) {
+      const tilmeld = enforceTilmeld(this);
+      await tilmeld.login(this, true);
+      return {
+        result: true,
+        message: 'You have logged out of all other sessions.',
+      };
+    } else {
+      return { result: false, message: "Couldn't save revocation date." };
+    }
+  }
+
+  public async $hasTOTPSecret() {
+    return this.$data.totpSecret != null;
+  }
+
+  /**
+   * Check the given code against the user's TOTP secret.
+   *
+   * @param code The code in question.
+   * @returns True if the code is valid, otherwise false.
+   */
+  public $checkTOTPCode(code: string) {
+    if (this.$data.totpSecret == null) {
+      return false;
+    }
+
+    const tilmeld = enforceTilmeld(this);
+
+    const totp = new TOTP({
+      issuer: tilmeld.config.appName,
+      label: this.$data.username,
+      algorithm: 'SHA1',
+      digits: 6,
+      period: 30,
+      secret: this.$data.totpSecret,
+    });
+
+    return totp.validate({ token: code, window: 2 }) != null;
+  }
+
+  /**
+   * A frontend accessible method to generate a new TOTP secret.
+   *
+   * @returns An object with 'uri', 'qrcode', and 'secret'.
+   */
+  public async $getNewTOTPSecret() {
+    const tilmeld = enforceTilmeld(this);
+
+    if (this.$data.totpSecret != null) {
+      throw new BadDataError('You already have a 2FA secret.');
+    }
+
+    const secret = new Secret();
+
+    const totp = new TOTP({
+      issuer: tilmeld.config.appName,
+      label: this.$data.username,
+      algorithm: 'SHA1',
+      digits: 6,
+      period: 30,
+      secret,
+    });
+
+    const uri = totp.toString();
+
+    const qrcode = await toDataURL(uri);
+
+    return {
+      uri,
+      qrcode,
+      secret: secret.base32,
+    };
+  }
+
+  /**
+   * A frontend accessible method to save a TOTP secret into the user's account.
+   *
+   * @param data The input data from the client.
+   * @returns An object with a boolean 'result' entry and a 'message' entry.
+   */
+  public async $saveTOTPSecret(data: {
+    password: string;
+    secret: string;
+    code: string;
+  }): Promise<{ result: boolean; message: string }> {
+    if (!this.$checkPassword(data.password ?? '')) {
+      return { result: false, message: 'Incorrect password.' };
+    }
+
+    if (this.$data.totpSecret != null) {
+      return { result: false, message: 'You already have a 2FA secret.' };
+    }
+
+    if (
+      data.secret == null ||
+      typeof data.secret !== 'string' ||
+      data.secret === ''
+    ) {
+      return { result: false, message: '2FA secret is invalid.' };
+    }
+
+    if (
+      data.code == null ||
+      typeof data.code !== 'string' ||
+      data.code.length !== 6
+    ) {
+      return { result: false, message: '2FA code is invalid.' };
+    }
+
+    const tilmeld = enforceTilmeld(this);
+
+    const totp = new TOTP({
+      issuer: tilmeld.config.appName,
+      label: this.$data.username,
+      algorithm: 'SHA1',
+      digits: 6,
+      period: 30,
+      secret: data.secret,
+    });
+
+    if (totp.validate({ token: data.code, window: 2 }) == null) {
+      return { result: false, message: '2FA code is incorrect.' };
+    }
+
+    this.$data.totpSecret = data.secret;
+
+    if (await this.$save()) {
+      return { result: true, message: 'Your two factor secret is now set.' };
+    } else {
+      return { result: false, message: "Couldn't save two factor secret." };
+    }
+  }
+
+  /**
+   * A frontend accessible method to remove the TOTP secret from the user's
+   * account.
+   *
+   * @param data The input data from the client.
+   * @returns An object with a boolean 'result' entry and a 'message' entry.
+   */
+  public async $removeTOTPSecret(data?: {
+    password: string;
+    code: string;
+  }): Promise<{ result: boolean; message: string }> {
+    const tilmeld = enforceTilmeld(this);
+
+    if (data) {
+      if (!this.$checkPassword(data.password ?? '')) {
+        return { result: false, message: 'Incorrect password.' };
+      }
+
+      if (
+        data.code == null ||
+        typeof data.code !== 'string' ||
+        data.code.length !== 6
+      ) {
+        return { result: false, message: '2FA code is invalid.' };
+      }
+
+      if (this.$data.totpSecret == null) {
+        return { result: false, message: "You don't have a 2FA secret." };
+      }
+
+      const totp = new TOTP({
+        issuer: tilmeld.config.appName,
+        label: this.$data.username,
+        algorithm: 'SHA1',
+        digits: 6,
+        period: 30,
+        secret: this.$data.totpSecret,
+      });
+
+      if (totp.validate({ token: data.code, window: 2 }) == null) {
+        return { result: false, message: '2FA code is incorrect.' };
+      }
+    } else if (!tilmeld.gatekeeper('tilmeld/admin')) {
+      return {
+        result: false,
+        message: 'You must provide your password and 2FA code.',
+      };
+    }
+
+    delete this.$data.totpSecret;
+
+    if (await this.$save()) {
+      return {
+        result: true,
+        message: 'Two factor secret has been removed.',
+      };
+    } else {
+      return { result: false, message: "Couldn't remove two factor secret." };
+    }
+  }
+
   /**
    * Check that a username is valid.
    *
    * @returns An object with a boolean 'result' entry and a 'message' entry.
    */
   public async $checkUsername(): Promise<{ result: boolean; message: string }> {
-    const tilmeld = this.$nymph.tilmeld as Tilmeld;
+    const tilmeld = enforceTilmeld(this);
+
+    this.$nymph.config.debugInfo(
+      'tilmeld',
+      `Username check "${this.$data.username}".`,
+    );
+
     if (!tilmeld.config.emailUsernames) {
-      if (this.$data.username == null || !this.$data.username.length) {
-        return { result: false, message: 'Please specify a username.' };
+      let [username, domain] = tilmeld.config.domainSupport
+        ? splitn(this.$data.username ?? '', '@', 2)
+        : [this.$data.username, null];
+
+      // Lowercase the domain part.
+      if (domain) {
+        domain = domain.toLowerCase();
+        this.$data.username = `${username}@${domain}`;
       }
+
       if (
-        tilmeld.config.maxUsernameLength > 0 &&
-        this.$data.username.length > tilmeld.config.maxUsernameLength
+        this.$data.username == null ||
+        !this.$data.username.length ||
+        username == null ||
+        !username.length
       ) {
+        return { result: false, message: 'Please specify a username.' };
+      }
+      if (username.length < tilmeld.config.minUsernameLength) {
+        return {
+          result: false,
+          message:
+            'Usernames must be at least ' +
+            tilmeld.config.minUsernameLength +
+            ' characters.',
+        };
+      }
+      if (username.length > tilmeld.config.maxUsernameLength) {
         return {
           result: false,
           message:
@@ -1076,22 +1851,39 @@ export default class User extends AbleObject<UserData> {
       }
 
       if (
-        difference(
-          this.$data.username.split(''),
-          tilmeld.config.validChars.split('')
-        ).length
+        difference(username.split(''), tilmeld.config.validChars.split(''))
+          .length
       ) {
         return {
           result: false,
           message: tilmeld.config.validCharsNotice,
         };
       }
-      if (!tilmeld.config.validRegex.test(this.$data.username)) {
+      if (!tilmeld.config.validRegex.test(username)) {
         return {
           result: false,
           message: tilmeld.config.validRegexNotice,
         };
       }
+      if (domain != null) {
+        if (!tilmeld.config.validDomainRegex.test(domain)) {
+          return {
+            result: false,
+            message: tilmeld.config.validDomainRegexNotice,
+          };
+        }
+        if (
+          !this.$skipAcWhenSaving &&
+          !this.$is(tilmeld.currentUser) &&
+          !tilmeld.gatekeeper(`tilmeld/domain/${domain}/admin`)
+        ) {
+          return {
+            result: false,
+            message:
+              "You don't have the authority to manage users on this domain.",
+          };
+        }
+      }
 
       const selector: Selector = {
         type: '&',
@@ -1105,12 +1897,24 @@ export default class User extends AbleObject<UserData> {
       }
       const test = await this.$nymph.getEntity(
         { class: tilmeld.User, skipAc: true },
-        selector
+        selector,
       );
       if (test != null) {
         return { result: false, message: 'That username is taken.' };
       }
 
+      for (let callback of (this.constructor as typeof User)
+        .checkUsernameCallbacks) {
+        if (callback) {
+          const result = await callback(this, {
+            username: this.$data.username,
+          });
+          if (!result.result) {
+            return { message: 'Username is not available.', ...result };
+          }
+        }
+      }
+
       return {
         result: true,
         message:
@@ -1121,10 +1925,16 @@ export default class User extends AbleObject<UserData> {
       if (this.$data.username == null || !this.$data.username.length) {
         return { result: false, message: 'Please specify an email.' };
       }
-      if (
-        tilmeld.config.maxUsernameLength > 0 &&
-        this.$data.username.length > tilmeld.config.maxUsernameLength
-      ) {
+      if (this.$data.username.length < tilmeld.config.minUsernameLength) {
+        return {
+          result: false,
+          message:
+            'Emails must be at least ' +
+            tilmeld.config.minUsernameLength +
+            ' characters.',
+        };
+      }
+      if (this.$data.username.length > tilmeld.config.maxUsernameLength) {
         return {
           result: false,
           message:
@@ -1144,7 +1954,13 @@ export default class User extends AbleObject<UserData> {
    * @returns An object with a boolean 'result' entry and a 'message' entry.
    */
   public async $checkEmail(): Promise<{ result: boolean; message: string }> {
-    const tilmeld = this.$nymph.tilmeld as Tilmeld;
+    const tilmeld = enforceTilmeld(this);
+
+    this.$nymph.config.debugInfo(
+      'tilmeld',
+      `Email check "${this.$data.email}".`,
+    );
+
     if (this.$data.email == null || !this.$data.email.length) {
       if (tilmeld.config.verifyEmail) {
         return { result: false, message: 'Please specify an email.' };
@@ -1167,7 +1983,7 @@ export default class User extends AbleObject<UserData> {
     }
     const test = await this.$nymph.getEntity(
       { class: tilmeld.User, skipAc: true },
-      selector
+      selector,
     );
     if (test != null) {
       return {
@@ -1189,7 +2005,13 @@ export default class User extends AbleObject<UserData> {
    * @returns An object with a boolean 'result' entry and a 'message' entry.
    */
   public async $checkPhone(): Promise<{ result: boolean; message: string }> {
-    const tilmeld = this.$nymph.tilmeld as Tilmeld;
+    const tilmeld = enforceTilmeld(this);
+
+    this.$nymph.config.debugInfo(
+      'tilmeld',
+      `Phone check "${this.$data.phone}".`,
+    );
+
     if (this.$data.phone == null || !this.$data.phone.length) {
       return { result: false, message: 'Please specify a phone number.' };
     }
@@ -1211,7 +2033,7 @@ export default class User extends AbleObject<UserData> {
     }
     const test = await this.$nymph.getEntity(
       { class: tilmeld.User, skipAc: true },
-      selector
+      selector,
     );
     if (test != null) {
       return { result: false, message: 'Phone number is in use.' };
@@ -1228,7 +2050,7 @@ export default class User extends AbleObject<UserData> {
     password: string;
     additionalData?: { [k: string]: any };
   }): Promise<{ result: boolean; loggedin: boolean; message: string }> {
-    let tilmeld = this.$nymph.tilmeld as Tilmeld;
+    let tilmeld = enforceTilmeld(this);
     if (!tilmeld.config.allowRegistration) {
       return {
         result: false,
@@ -1244,21 +2066,6 @@ export default class User extends AbleObject<UserData> {
       };
     }
 
-    try {
-      for (let callback of (this.constructor as typeof User)
-        .beforeRegisterCallbacks) {
-        if (callback) {
-          await callback(this, data);
-        }
-      }
-    } catch (e: any) {
-      return {
-        result: false,
-        loggedin: false,
-        message: e.message,
-      };
-    }
-
     if (!('password' in data) || !data.password.length) {
       return {
         result: false,
@@ -1272,7 +2079,7 @@ export default class User extends AbleObject<UserData> {
     }
 
     this.$password(data.password);
-    if (tilmeld.config.regFields.indexOf('name') !== -1) {
+    if (tilmeld.config.regFields.includes('name')) {
       this.$data.name =
         this.$data.nameFirst +
         (this.$data.nameMiddle == null ? '' : ' ' + this.$data.nameMiddle) +
@@ -1289,75 +2096,34 @@ export default class User extends AbleObject<UserData> {
     const transaction = 'tilmeld-register-' + nanoid();
     const nymph = this.$nymph;
     const tnymph = await this.$nymph.startTransaction(transaction);
-    this.$nymph = tnymph;
-    tilmeld = this.$nymph.tilmeld as Tilmeld;
+    this.$setNymph(tnymph);
+    tilmeld = enforceTilmeld(this);
+
+    let message = '';
+    let loggedin = false;
 
     try {
-      // Add primary group.
-      let generatedPrimaryGroup: (Group & GroupData) | null = null;
-      if (tilmeld.config.generatePrimary) {
-        // Generate a new primary group for the user.
-        generatedPrimaryGroup = await tilmeld.Group.factory();
-        generatedPrimaryGroup.groupname = this.$data.username;
-        generatedPrimaryGroup.avatar = this.$data.avatar;
-        generatedPrimaryGroup.name = this.$data.name;
-        generatedPrimaryGroup.email = this.$data.email;
-        const parent = await tnymph.getEntity(
-          { class: tilmeld.Group },
-          {
-            type: '&',
-            equal: ['defaultPrimary', true],
-          }
-        );
-        if (parent != null) {
-          generatedPrimaryGroup.parent = parent;
-        }
-        if (!(await generatedPrimaryGroup.$saveSkipAC())) {
-          await tnymph.rollback(transaction);
-          this.$nymph = nymph;
-          return {
-            result: false,
-            loggedin: false,
-            message: 'Error creating primary group for user.',
-          };
-        }
-        this.$data.group = generatedPrimaryGroup;
-      } else {
-        // Add the default primary.
-        const group = await tnymph.getEntity(
-          { class: tilmeld.Group },
-          {
-            type: '&',
-            equal: ['defaultPrimary', true],
+      try {
+        for (let callback of (this.constructor as typeof User)
+          .beforeRegisterCallbacks) {
+          if (callback) {
+            await callback(this, data);
           }
-        );
-        if (group != null) {
-          this.$data.group = group;
         }
+      } catch (e: any) {
+        await tnymph.rollback(transaction);
+        this.$setNymph(nymph);
+        return {
+          result: false,
+          loggedin: false,
+          message: e.message,
+        };
       }
 
-      // Add secondary groups.
-      if (tilmeld.config.verifyEmail && tilmeld.config.unverifiedAccess) {
-        // Add the default secondaries for unverified users.
-        this.$data.groups = await tnymph.getEntities(
-          { class: tilmeld.Group },
-          {
-            type: '&',
-            equal: ['unverifiedSecondary', true],
-          }
-        );
-      } else {
-        // Add the default secondaries.
-        this.$data.groups = await tnymph.getEntities(
-          { class: tilmeld.Group },
-          {
-            type: '&',
-            equal: ['defaultSecondary', true],
-          }
-        );
-      }
-
-      if (tilmeld.config.verifyEmail) {
+      if (
+        tilmeld.config.userFields.includes('email') &&
+        tilmeld.config.verifyEmail
+      ) {
         // The user will be enabled after verifying their e-mail address.
         if (!tilmeld.config.unverifiedAccess) {
           this.$data.enabled = false;
@@ -1366,7 +2132,7 @@ export default class User extends AbleObject<UserData> {
         this.$data.enabled = true;
       }
 
-      // If create_admin is true and there are no other users, grant
+      // If createAdmin is true and there are no other users, grant
       // "system/admin".
       let madeAdmin = false;
       if (tilmeld.config.createAdmin) {
@@ -1377,6 +2143,15 @@ export default class User extends AbleObject<UserData> {
           return: 'guid',
         });
         // Make sure it's not just null, cause that means an error.
+        if (otherUsers == null) {
+          await tnymph.rollback(transaction);
+          this.$setNymph(nymph);
+          return {
+            result: false,
+            loggedin: false,
+            message: 'An error occurred.',
+          };
+        }
         if (!otherUsers.length) {
           this.$grant('system/admin');
           this.$data.enabled = true;
@@ -1384,7 +2159,15 @@ export default class User extends AbleObject<UserData> {
         }
       }
 
+      this.$nymph.config.debugLog(
+        'tilmeld',
+        `Registering new user "${this.$data.username}".`,
+      );
       if (await this.$saveSkipAC()) {
+        this.$nymph.config.debugLog(
+          'tilmeld',
+          `New user registered "${this.$data.username}".`,
+        );
         // Send the new user registered email.
         if (tilmeld.config.userRegisteredRecipient != null) {
           await tilmeld.config.sendEmail(
@@ -1403,33 +2186,16 @@ export default class User extends AbleObject<UserData> {
                 userPhone: this.$data.phone,
               },
             },
-            this
+            this,
           );
         }
 
-        let message = '';
-        let loggedin = false;
-
-        // Save the primary group.
-        if (generatedPrimaryGroup != null) {
-          generatedPrimaryGroup.user = this;
-          if (!(await generatedPrimaryGroup.$saveSkipAC())) {
-            await tnymph.rollback(transaction);
-            this.$nymph = nymph;
-            return {
-              result: false,
-              loggedin: false,
-              message:
-                'Your primary group could not be assigned. Please try again later.',
-            };
-          }
-        }
-
         // Finish up.
         if (
           tilmeld.config.verifyEmail &&
           !tilmeld.config.unverifiedAccess &&
-          !madeAdmin
+          !madeAdmin &&
+          tilmeld.config.userFields.includes('email')
         ) {
           message +=
             `Almost there. An email has been sent to ${this.$data.email} ` +
@@ -1437,9 +2203,10 @@ export default class User extends AbleObject<UserData> {
         } else if (
           tilmeld.config.verifyEmail &&
           tilmeld.config.unverifiedAccess &&
-          !madeAdmin
+          !madeAdmin &&
+          tilmeld.config.userFields.includes('email')
         ) {
-          if (!tilmeld.login(this, true)) {
+          if (!(await tilmeld.login(this, true))) {
             throw new Error('An error occurred trying to log you in.');
           }
           message +=
@@ -1448,7 +2215,7 @@ export default class User extends AbleObject<UserData> {
             'registration.';
           loggedin = true;
         } else {
-          if (!tilmeld.login(this, true)) {
+          if (!(await tilmeld.login(this, true))) {
             throw new Error('An error occurred trying to log you in.');
           }
           message += "You're now registered and logged in!";
@@ -1464,23 +2231,13 @@ export default class User extends AbleObject<UserData> {
             });
           }
         }
-
-        try {
-          await tnymph.commit(transaction);
-          this.$nymph = nymph;
-          this.$nymph.tilmeld?.fillSession(this);
-        } catch (e: any) {
-          throw e;
-        }
-
-        return {
-          result: true,
-          loggedin,
-          message,
-        };
       } else {
+        this.$nymph.config.debugError(
+          'tilmeld',
+          `Error registering new user "${this.$data.username}".`,
+        );
         await tnymph.rollback(transaction);
-        this.$nymph = nymph;
+        this.$setNymph(nymph);
         return {
           result: false,
           loggedin: false,
@@ -1488,28 +2245,100 @@ export default class User extends AbleObject<UserData> {
         };
       }
     } catch (e: any) {
+      this.$nymph.config.debugError(
+        'tilmeld',
+        `Error registering new user "${this.$data.username}": ${e}`,
+      );
       await tnymph.rollback(transaction);
-      this.$nymph = nymph;
+      this.$setNymph(nymph);
+      throw e;
+    }
+
+    try {
+      await tnymph.commit(transaction);
+      this.$setNymph(nymph);
+      await this.$nymph.tilmeld?.fillSession(this);
+    } catch (e: any) {
       throw e;
     }
+
+    return {
+      result: true,
+      loggedin,
+      message,
+    };
   }
 
   public async $save() {
-    let tilmeld = this.$nymph.tilmeld as Tilmeld;
+    let tilmeld = enforceTilmeld(this);
     if (this.$data.username == null || !this.$data.username.trim().length) {
       return false;
     }
 
     if (
+      !this.$skipAcWhenSaving &&
       tilmeld.gatekeeper('tilmeld/admin') &&
       !tilmeld.gatekeeper('system/admin') &&
-      this.$gatekeeper('system/admin')
+      this.$data.abilities?.includes('system/admin')
     ) {
-      throw new BadDataError(
-        "You don't have the authority to modify system admins."
+      throw new AccessControlError(
+        "You don't have the authority to modify system admins.",
       );
     }
 
+    // Lowercase the domain part.
+    if (tilmeld.config.domainSupport) {
+      const [username, domain] = splitn(this.$data.username ?? '', '@', 2);
+      if (domain) {
+        this.$data.username = `${username}@${domain.toLowerCase()}`;
+      }
+    }
+
+    if (tilmeld.config.domainSupport) {
+      const [_username, domain] = splitn(this.$data.username ?? '', '@', 2);
+      const [_originalUsername, originalDomain] = splitn(
+        this.$originalUsername ?? '',
+        '@',
+        2,
+      );
+
+      if (
+        this.guid != null &&
+        ((originalDomain == null && domain != null) ||
+          (domain == null && originalDomain != null))
+      ) {
+        throw new AccessControlError(
+          "Users can't switch to or from having a domain once created.",
+        );
+      }
+
+      if (
+        !this.$skipAcWhenSaving &&
+        !tilmeld.gatekeeper('tilmeld/admin') &&
+        !tilmeld.gatekeeper('system/admin')
+      ) {
+        if (
+          domain != null &&
+          !this.$is(tilmeld.currentUser) &&
+          !tilmeld.gatekeeper(`tilmeld/domain/${domain}/admin`)
+        ) {
+          throw new AccessControlError(
+            "You don't have the authority to modify users on this domain.",
+          );
+        }
+        if (
+          originalDomain != null &&
+          originalDomain !== domain &&
+          (!tilmeld.gatekeeper(`tilmeld/domain/${domain}/admin`) ||
+            !tilmeld.gatekeeper(`tilmeld/domain/${originalDomain}/admin`))
+        ) {
+          throw new AccessControlError(
+            "You don't have the authority to modify users on this domain.",
+          );
+        }
+      }
+    }
+
     let sendVerification = false;
 
     // Formatting.
@@ -1528,49 +2357,88 @@ export default class User extends AbleObject<UserData> {
     this.$data.enabled = !!this.$data.enabled;
 
     // Clear empty values.
-    if (this.$data.nameFirst === '') {
+    if (
+      this.$data.nameFirst === '' ||
+      !tilmeld.config.userFields.includes('name')
+    ) {
       delete this.$data.nameFirst;
     }
-    if (this.$data.nameMiddle === '') {
+    if (
+      this.$data.nameMiddle === '' ||
+      !tilmeld.config.userFields.includes('name')
+    ) {
       delete this.$data.nameMiddle;
     }
-    if (this.$data.nameLast === '') {
+    if (
+      this.$data.nameLast === '' ||
+      !tilmeld.config.userFields.includes('name')
+    ) {
       delete this.$data.nameLast;
     }
-    if (this.$data.name === '') {
+    if (this.$data.name === '' || !tilmeld.config.userFields.includes('name')) {
       delete this.$data.name;
     }
-    if (this.$data.email === '') {
+    if (
+      this.$data.email === '' ||
+      !tilmeld.config.userFields.includes('email')
+    ) {
       delete this.$data.email;
     }
     if (this.$data.avatar === '') {
       delete this.$data.avatar;
     }
-    if (this.$data.phone === '') {
+    if (
+      this.$data.phone === '' ||
+      !tilmeld.config.userFields.includes('phone')
+    ) {
       delete this.$data.phone;
     }
-    if (this.$data.secret === '') {
+    if (
+      this.$data.secret === '' ||
+      !tilmeld.config.userFields.includes('email')
+    ) {
       delete this.$data.secret;
     }
-    if (this.$data.emailChangeDate === 0) {
+    if (
+      this.$data.emailChangeDate === 0 ||
+      !tilmeld.config.userFields.includes('email')
+    ) {
       delete this.$data.emailChangeDate;
     }
-    if (this.$data.newEmailSecret === '') {
+    if (
+      this.$data.newEmailSecret === '' ||
+      !tilmeld.config.userFields.includes('email')
+    ) {
       delete this.$data.newEmailSecret;
     }
-    if (this.$data.newEmailAddress === '') {
+    if (
+      this.$data.newEmailAddress === '' ||
+      !tilmeld.config.userFields.includes('email')
+    ) {
       delete this.$data.newEmailAddress;
     }
-    if (this.$data.cancelEmailSecret === '') {
+    if (
+      this.$data.cancelEmailSecret === '' ||
+      !tilmeld.config.userFields.includes('email')
+    ) {
       delete this.$data.cancelEmailSecret;
     }
-    if (this.$data.cancelEmailAddress === '') {
+    if (
+      this.$data.cancelEmailAddress === '' ||
+      !tilmeld.config.userFields.includes('email')
+    ) {
       delete this.$data.cancelEmailAddress;
     }
-    if (this.$data.recoverSecret === '') {
+    if (
+      this.$data.recoverSecret === '' ||
+      !tilmeld.config.userFields.includes('email')
+    ) {
       delete this.$data.recoverSecret;
     }
-    if (this.$data.recoverSecretDate === 0) {
+    if (
+      this.$data.recoverSecretDate === 0 ||
+      !tilmeld.config.userFields.includes('email')
+    ) {
       delete this.$data.recoverSecretDate;
     }
     if (this.$data.password === '') {
@@ -1588,7 +2456,10 @@ export default class User extends AbleObject<UserData> {
     if (!unCheck.result) {
       throw new BadUsernameError(unCheck.message);
     }
-    if (!tilmeld.config.emailUsernames) {
+    if (
+      !tilmeld.config.emailUsernames &&
+      tilmeld.config.userFields.includes('email')
+    ) {
       const emCheck = await this.$checkEmail();
       if (!emCheck.result) {
         throw new BadEmailError(emCheck.message);
@@ -1596,7 +2467,10 @@ export default class User extends AbleObject<UserData> {
     }
 
     // Email changes.
-    if (!tilmeld.gatekeeper('tilmeld/admin')) {
+    if (
+      !tilmeld.gatekeeper('tilmeld/admin') &&
+      tilmeld.config.userFields.includes('email')
+    ) {
       // The user isn't an admin, so email address changes should contain some
       // security measures.
       if (tilmeld.config.verifyEmail) {
@@ -1604,7 +2478,7 @@ export default class User extends AbleObject<UserData> {
         if (this.guid == null) {
           // If this is the first user, they'll be made an admin, so they don't
           // need to verify.
-          if ((this.$data.abilities?.indexOf('system/admin') ?? -1) === -1) {
+          if (!this.$data.abilities?.includes('system/admin')) {
             this.$data.secret = nanoid();
             sendVerification = true;
           }
@@ -1624,10 +2498,10 @@ export default class User extends AbleObject<UserData> {
                 new Date(
                   strtotime(
                     '+' + tilmeld.config.emailRateLimit,
-                    Math.floor(this.$data.emailChangeDate / 1000)
-                  ) * 1000
+                    Math.floor(this.$data.emailChangeDate / 1000),
+                  ) * 1000,
                 ).toString() +
-                ' to change your email address again.'
+                ' to change your email address again.',
             );
           } else {
             if (
@@ -1682,51 +2556,157 @@ export default class User extends AbleObject<UserData> {
       throw new BadDataError('A password is required.');
     }
 
-    try {
-      tilmeld.config.validatorUser(this);
-    } catch (e: any) {
-      throw new BadDataError(e?.message);
-    }
-
     // Start transaction.
-    const transaction = 'tilmeld-save-' + nanoid();
+    const transaction = 'tilmeld-save-user-' + (this.guid || nanoid());
     const nymph = this.$nymph;
     const tnymph = await this.$nymph.startTransaction(transaction);
-    this.$nymph = tnymph;
-    tilmeld = this.$nymph.tilmeld as Tilmeld;
+    this.$setNymph(tnymph);
+    tilmeld = enforceTilmeld(this);
+    const Group = tnymph.getEntityClass(GroupClass);
 
-    if (
-      this.$data.group != null &&
-      this.$data.group.user != null &&
-      this.$is(this.$data.group.user)
-    ) {
-      try {
+    try {
+      let group = this.$data.group;
+      if (group != null) {
+        // Make sure to get fresh group data.
+        if (group.$asleep()) {
+          await group.$wake();
+        } else {
+          if (!(await group.$refresh())) {
+            throw new Error("Couldn't retrieve primary group info.");
+          }
+        }
+      }
+      if (group == null && this.guid == null) {
+        if (tilmeld.config.generatePrimary) {
+          // Generate a new primary group for the user.
+          group = await Group.factory();
+          group.user = this;
+          const parent = await tnymph.getEntity(
+            { class: Group },
+            {
+              type: '&',
+              equal: ['defaultPrimary', true],
+            },
+          );
+          if (parent != null) {
+            group.parent = parent;
+          }
+        } else {
+          // Add the default primary.
+          const group = await tnymph.getEntity(
+            { class: Group },
+            {
+              type: '&',
+              equal: ['defaultPrimary', true],
+            },
+          );
+          if (group != null) {
+            this.$data.group = group;
+          }
+        }
+      }
+      if (group != null && group.user != null && this.$is(group.user)) {
         // Update the user's generated primary group.
-        this.$data.group.groupname = this.$data.username;
-        this.$data.group.avatar = this.$data.avatar;
-        this.$data.group.email = this.$data.email;
-        this.$data.group.name = this.$data.name;
-        this.$data.group.phone = this.$data.phone;
-        await this.$data.group.$saveSkipAC();
+        let changed = false;
+        if (group.groupname !== this.$data.username) {
+          group.groupname = this.$data.username;
+          changed = true;
+        }
+        if (group.avatar !== this.$data.avatar) {
+          group.avatar = this.$data.avatar;
+          changed = true;
+        }
+        if (
+          tilmeld.config.userFields.includes('email') &&
+          group.email !== this.$data.email
+        ) {
+          group.email = this.$data.email;
+          changed = true;
+        }
+        if (
+          tilmeld.config.userFields.includes('name') &&
+          group.name !== this.$data.name
+        ) {
+          group.name = this.$data.name;
+          changed = true;
+        }
+        if (
+          tilmeld.config.userFields.includes('phone') &&
+          group.phone !== this.$data.phone
+        ) {
+          group.phone = this.$data.phone;
+          changed = true;
+        }
+        if (changed || group.guid == null) {
+          if (!(await group.$saveSkipAC())) {
+            throw Error('Error updating primary group for user.');
+          }
+        }
+        this.$data.group = group;
+      }
+
+      if (this.$data.groups == null || this.$data.groups.length === 0) {
+        // Add secondary groups.
+        if (
+          tilmeld.config.userFields.includes('email') &&
+          tilmeld.config.verifyEmail &&
+          tilmeld.config.unverifiedAccess &&
+          this.$data.secret != null
+        ) {
+          // Add the default secondaries for unverified users.
+          this.$data.groups = await tnymph.getEntities(
+            { class: Group },
+            {
+              type: '&',
+              equal: ['unverifiedSecondary', true],
+            },
+          );
+        } else {
+          // Add the default secondaries.
+          this.$data.groups = await tnymph.getEntities(
+            { class: Group },
+            {
+              type: '&',
+              equal: ['defaultSecondary', true],
+            },
+          );
+        }
+      }
+
+      try {
+        tilmeld.config.validatorUser(tilmeld, this);
       } catch (e: any) {
-        await tnymph.rollback(transaction);
-        this.$nymph = nymph;
-        throw e;
+        throw new BadDataError(e?.message);
       }
+    } catch (e: any) {
+      await tnymph.rollback(transaction);
+      this.$setNymph(nymph);
+      throw e;
     }
 
-    let ret: boolean;
+    let ret = false;
     let preGuid = this.guid;
     let preCdate = this.cdate;
     let preMdate = this.mdate;
 
     try {
+      for (let callback of (this.constructor as typeof User)
+        .beforeSaveCallbacks) {
+        if (callback) {
+          await callback(this);
+        }
+      }
+
       ret = await super.$save();
     } catch (e: any) {
       await tnymph.rollback(transaction);
-      this.$nymph = nymph;
+      this.guid = preGuid;
+      this.cdate = preCdate;
+      this.mdate = preMdate;
+      this.$setNymph(nymph);
       throw e;
     }
+
     if (ret) {
       if (sendVerification) {
         // The email has changed, so send a new verification email.
@@ -1735,23 +2715,48 @@ export default class User extends AbleObject<UserData> {
           this.guid = preGuid;
           this.cdate = preCdate;
           this.mdate = preMdate;
-          this.$nymph = nymph;
+          this.$setNymph(nymph);
           throw new Error("Couldn't send verification email.");
         }
       }
 
       this.$descendantGroups = undefined;
       this.$gatekeeperCache = undefined;
-      await tnymph.commit(transaction);
 
-      if ((nymph.tilmeld as Tilmeld).User.current(true).$is(this)) {
-        // Update the user in the session cache.
-        (nymph.tilmeld as Tilmeld).fillSession(this);
+      try {
+        for (let callback of (this.constructor as typeof User)
+          .afterSaveCallbacks) {
+          if (callback) {
+            await callback(this);
+          }
+        }
+      } catch (e: any) {
+        await tnymph.rollback(transaction);
+        this.guid = preGuid;
+        this.cdate = preCdate;
+        this.mdate = preMdate;
+        this.$setNymph(nymph);
+        throw e;
       }
+
+      ret = await tnymph.commit(transaction);
     } else {
       await tnymph.rollback(transaction);
     }
-    this.$nymph = nymph;
+    this.$setNymph(nymph);
+
+    if (ret) {
+      this.$originalEmail = this.$data.email;
+      this.$originalUsername = this.$data.username;
+
+      const tilmeld = enforceTilmeld(nymph);
+
+      if (tilmeld.User.current(true).$is(this)) {
+        // Update the user in the session cache.
+        await tilmeld.fillSession(this);
+      }
+    }
+
     return ret;
   }
 
@@ -1772,53 +2777,167 @@ export default class User extends AbleObject<UserData> {
   }
 
   public async $delete() {
-    const tilmeld = this.$nymph.tilmeld as Tilmeld;
-    if (!tilmeld.gatekeeper('tilmeld/admin')) {
-      throw new BadDataError("You don't have the authority to delete users.");
+    const tilmeld = enforceTilmeld(this);
+    if (!this.$skipAcWhenDeleting && !tilmeld.gatekeeper('tilmeld/admin')) {
+      throw new AccessControlError(
+        "You don't have the authority to delete users.",
+      );
     }
     if (
+      !this.$skipAcWhenDeleting &&
       !tilmeld.gatekeeper('system/admin') &&
-      this.$gatekeeper('system/admin')
+      this.$data.abilities?.includes('system/admin')
     ) {
-      throw new BadDataError(
-        "You don't have the authority to delete system admins."
+      throw new AccessControlError(
+        "You don't have the authority to delete system admins.",
       );
     }
-    if (tilmeld.User.current(true).$is(this)) {
-      await this.$logout();
+    if (this.$data.username !== this.$originalUsername) {
+      throw new AccessControlError(
+        "You can't delete a user while switching their username.",
+      );
     }
-    return await super.$delete();
+
+    const transaction = 'tilmeld-delete-user-' + this.guid;
+    const nymph = this.$nymph;
+    const tnymph = await nymph.startTransaction(transaction);
+    this.$setNymph(tnymph);
+
+    let success = false;
+
+    try {
+      if (!(await this.$refresh())) {
+        throw new BadDataError('User could not be refreshed.');
+      }
+
+      if (this.$data.group != null) {
+        if (this.$data.group.$asleep()) {
+          await this.$data.group.$wake();
+        } else {
+          if (!(await this.$data.group.$refresh())) {
+            throw new BadDataError('Group could not be refreshed.');
+          }
+        }
+      }
+
+      for (let callback of (this.constructor as typeof User)
+        .beforeDeleteCallbacks) {
+        if (callback) {
+          await callback(this);
+        }
+      }
+
+      if (tilmeld.User.current(true).$is(this)) {
+        await this.$logout();
+      }
+
+      if (this.$data.group != null && this.$is(this.$data.group.user)) {
+        // Read the skip ac value here, because super.$delete changes it.
+        const $skipAcWhenDeleting = this.$skipAcWhenDeleting;
+
+        // Delete the user.
+        success = await super.$delete();
+        if (success) {
+          // Delete the generated group.
+          success = $skipAcWhenDeleting
+            ? await this.$data.group.$deleteSkipAC()
+            : await this.$data.group.$delete();
+        }
+      } else {
+        success = await super.$delete();
+      }
+    } catch (e: any) {
+      await tnymph.rollback(transaction);
+      this.$setNymph(nymph);
+      throw e;
+    }
+
+    if (success) {
+      try {
+        for (let callback of (this.constructor as typeof User)
+          .afterDeleteCallbacks) {
+          if (callback) {
+            await callback(this);
+          }
+        }
+      } catch (e: any) {
+        await tnymph.rollback(transaction);
+        this.$setNymph(nymph);
+        throw e;
+      }
+      success = await tnymph.commit(transaction);
+    } else {
+      await tnymph.rollback(transaction);
+    }
+    this.$setNymph(nymph);
+    return success;
+  }
+
+  /*
+   * This should *never* be accessible on the client.
+   */
+  async $deleteSkipAC() {
+    this.$skipAcWhenDeleting = true;
+    return await this.$delete();
+  }
+
+  $tilmeldDeleteSkipAC() {
+    if (this.$skipAcWhenDeleting) {
+      this.$skipAcWhenDeleting = false;
+      return true;
+    }
+    return false;
   }
 
   public static on<T extends EventType>(
     event: T,
-    callback: T extends 'beforeRegister'
-      ? TilmeldBeforeRegisterCallback
-      : T extends 'afterRegister'
-      ? TilmeldAfterRegisterCallback
-      : T extends 'beforeLogin'
-      ? TilmeldBeforeLoginCallback
-      : T extends 'afterLogin'
-      ? TilmeldAfterLoginCallback
-      : T extends 'beforeLogout'
-      ? TilmeldBeforeLogoutCallback
-      : T extends 'afterLogout'
-      ? TilmeldAfterLogoutCallback
-      : never
+    callback: T extends 'checkUsername'
+      ? TilmeldCheckUsernameCallback
+      : T extends 'beforeRegister'
+        ? TilmeldBeforeRegisterCallback
+        : T extends 'afterRegister'
+          ? TilmeldAfterRegisterCallback
+          : T extends 'beforeSave'
+            ? TilmeldBeforeSaveCallback
+            : T extends 'afterSave'
+              ? TilmeldAfterSaveCallback
+              : T extends 'beforeLogin'
+                ? TilmeldBeforeLoginCallback
+                : T extends 'afterLogin'
+                  ? TilmeldAfterLoginCallback
+                  : T extends 'beforeLogout'
+                    ? TilmeldBeforeLogoutCallback
+                    : T extends 'afterLogout'
+                      ? TilmeldAfterLogoutCallback
+                      : T extends 'beforeDelete'
+                        ? TilmeldBeforeDeleteCallback
+                        : T extends 'afterDelete'
+                          ? TilmeldAfterDeleteCallback
+                          : never,
   ) {
-    const prop = (event + 'Callbacks') as T extends 'beforeRegister'
-      ? 'beforeRegisterCallbacks'
-      : T extends 'afterRegister'
-      ? 'afterRegisterCallbacks'
-      : T extends 'beforeLogin'
-      ? 'beforeLoginCallbacks'
-      : T extends 'afterLogin'
-      ? 'afterLoginCallbacks'
-      : T extends 'beforeLogout'
-      ? 'beforeLogoutCallbacks'
-      : T extends 'afterLogout'
-      ? 'afterLogoutCallbacks'
-      : never;
+    const prop = (event + 'Callbacks') as T extends 'checkUsername'
+      ? 'checkUsernameCallbacks'
+      : T extends 'beforeRegister'
+        ? 'beforeRegisterCallbacks'
+        : T extends 'afterRegister'
+          ? 'afterRegisterCallbacks'
+          : T extends 'beforeSave'
+            ? 'beforeSaveCallbacks'
+            : T extends 'afterSave'
+              ? 'afterSaveCallbacks'
+              : T extends 'beforeLogin'
+                ? 'beforeLoginCallbacks'
+                : T extends 'afterLogin'
+                  ? 'afterLoginCallbacks'
+                  : T extends 'beforeLogout'
+                    ? 'beforeLogoutCallbacks'
+                    : T extends 'afterLogout'
+                      ? 'afterLogoutCallbacks'
+                      : T extends 'beforeDelete'
+                        ? 'beforeDeleteCallbacks'
+                        : T extends 'afterDelete'
+                          ? 'afterDeleteCallbacks'
+                          : never;
     if (!(prop in this)) {
       throw new Error('Invalid event type.');
     }
@@ -1829,33 +2948,53 @@ export default class User extends AbleObject<UserData> {
 
   public static off<T extends EventType>(
     event: T,
-    callback: T extends 'beforeRegister'
-      ? TilmeldBeforeRegisterCallback
-      : T extends 'afterRegister'
-      ? TilmeldAfterRegisterCallback
-      : T extends 'beforeLogin'
-      ? TilmeldBeforeLoginCallback
-      : T extends 'afterLogin'
-      ? TilmeldAfterLoginCallback
-      : T extends 'beforeLogout'
-      ? TilmeldBeforeLogoutCallback
-      : T extends 'afterLogout'
-      ? TilmeldAfterLogoutCallback
-      : never
+    callback: T extends 'checkUsername'
+      ? TilmeldCheckUsernameCallback
+      : T extends 'beforeRegister'
+        ? TilmeldBeforeRegisterCallback
+        : T extends 'afterRegister'
+          ? TilmeldAfterRegisterCallback
+          : T extends 'beforeSave'
+            ? TilmeldBeforeSaveCallback
+            : T extends 'afterSave'
+              ? TilmeldAfterSaveCallback
+              : T extends 'beforeLogin'
+                ? TilmeldBeforeLoginCallback
+                : T extends 'afterLogin'
+                  ? TilmeldAfterLoginCallback
+                  : T extends 'beforeLogout'
+                    ? TilmeldBeforeLogoutCallback
+                    : T extends 'afterLogout'
+                      ? TilmeldAfterLogoutCallback
+                      : T extends 'beforeDelete'
+                        ? TilmeldBeforeDeleteCallback
+                        : T extends 'afterDelete'
+                          ? TilmeldAfterDeleteCallback
+                          : never,
   ) {
-    const prop = (event + 'Callbacks') as T extends 'beforeRegister'
-      ? 'beforeRegisterCallbacks'
-      : T extends 'afterRegister'
-      ? 'afterRegisterCallbacks'
-      : T extends 'beforeLogin'
-      ? 'beforeLoginCallbacks'
-      : T extends 'afterLogin'
-      ? 'afterLoginCallbacks'
-      : T extends 'beforeLogout'
-      ? 'beforeLogoutCallbacks'
-      : T extends 'afterLogout'
-      ? 'afterLogoutCallbacks'
-      : never;
+    const prop = (event + 'Callbacks') as T extends 'checkUsername'
+      ? 'checkUsernameCallbacks'
+      : T extends 'beforeRegister'
+        ? 'beforeRegisterCallbacks'
+        : T extends 'afterRegister'
+          ? 'afterRegisterCallbacks'
+          : T extends 'beforeSave'
+            ? 'beforeSaveCallbacks'
+            : T extends 'afterSave'
+              ? 'afterSaveCallbacks'
+              : T extends 'beforeLogin'
+                ? 'beforeLoginCallbacks'
+                : T extends 'afterLogin'
+                  ? 'afterLoginCallbacks'
+                  : T extends 'beforeLogout'
+                    ? 'beforeLogoutCallbacks'
+                    : T extends 'afterLogout'
+                      ? 'afterLogoutCallbacks'
+                      : T extends 'beforeDelete'
+                        ? 'beforeDeleteCallbacks'
+                        : T extends 'afterDelete'
+                          ? 'afterDeleteCallbacks'
+                          : never;
     if (!(prop in this)) {
       return false;
     }