@nymphjs/tilmeld 1.0.0-beta.90 → 1.0.0-beta.91

package/src/Group.ts

@@ -8,6 +8,7 @@ import type {
   Selector,
   SerializedEntityData,
 } from '@nymphjs/nymph';
+import { nanoid } from '@nymphjs/guid';
 import { difference, xor } from 'lodash-es';
 import { splitn } from '@sciactive/splitn';
 
@@ -23,6 +24,52 @@ import {
 import UserClass from './User.js';
 import type { UserData } from './User.js';
 
+export type GroupEventType =
+  | 'checkGroupname'
+  | 'beforeSave'
+  | 'afterSave'
+  | 'beforeDelete'
+  | 'afterDelete';
+/**
+ * This is run when the user has entered an otherwise valid groupname into the
+ * signup form. It should return a result, which when false will stop the
+ * process and return the included message, disallowing the groupname.
+ */
+export type TilmeldCheckGroupnameCallback = (
+  group: Group & GroupData,
+  data: { groupname: string },
+) => Promise<{ result: boolean; message?: string }>;
+/**
+ * This is run just before the group is saved, so all checks have passed.
+ *
+ * The transaction is available in `group.$nymph`.
+ */
+export type TilmeldBeforeGroupSaveCallback = (
+  group: Group & GroupData,
+) => Promise<void>;
+/**
+ * This is run before the transaction is committed, and you can perform
+ * additional functions on the transaction, which is available in
+ * `group.$nymph`.
+ */
+export type TilmeldAfterGroupSaveCallback = (
+  group: Group & GroupData,
+) => Promise<void>;
+/**
+ * The transaction is available in `group.$nymph`.
+ */
+export type TilmeldBeforeGroupDeleteCallback = (
+  group: Group & GroupData,
+) => Promise<void>;
+/**
+ * This is run before the transaction is committed, and you can perform
+ * additional functions on the transaction, which is available in
+ * `group.$nymph`.
+ */
+export type TilmeldAfterGroupDeleteCallback = (
+  group: Group & GroupData,
+) => Promise<void>;
+
 export type GroupData = {
   /**
    * The abilities granted to the group.
@@ -90,6 +137,11 @@ export default class Group extends AbleObject<GroupData> {
    */
   static ETYPE = 'tilmeld_group';
   static class = 'Group';
+  private static checkGroupnameCallbacks: TilmeldCheckGroupnameCallback[] = [];
+  private static beforeSaveCallbacks: TilmeldBeforeGroupSaveCallback[] = [];
+  private static afterSaveCallbacks: TilmeldAfterGroupSaveCallback[] = [];
+  private static beforeDeleteCallbacks: TilmeldBeforeGroupDeleteCallback[] = [];
+  private static afterDeleteCallbacks: TilmeldAfterGroupDeleteCallback[] = [];
 
   private static DEFAULT_PRIVATE_DATA = ['email', 'phone', 'abilities', 'user'];
   private static DEFAULT_ALLOWLIST_DATA: string[] = [];
@@ -677,6 +729,18 @@ export default class Group extends AbleObject<GroupData> {
         return { result: false, message: 'That groupname is taken.' };
       }
 
+      for (let callback of (this.constructor as typeof Group)
+        .checkGroupnameCallbacks) {
+        if (callback) {
+          const result = await callback(this, {
+            groupname: this.$data.groupname,
+          });
+          if (!result.result) {
+            return { message: 'Groupname is not available.', ...result };
+          }
+        }
+      }
+
       return {
         result: true,
         message:
@@ -755,7 +819,7 @@ export default class Group extends AbleObject<GroupData> {
   }
 
   public async $save() {
-    const tilmeld = enforceTilmeld(this);
+    let tilmeld = enforceTilmeld(this);
     if (this.$data.groupname == null || !this.$data.groupname.trim().length) {
       return false;
     }
@@ -932,11 +996,45 @@ export default class Group extends AbleObject<GroupData> {
       }
     }
 
-    const ret = await super.$save();
-    if (ret) {
-      this.$originalGroupname = this.$data.groupname;
+    const transaction = 'tilmeld-save-group-' + (this.guid || nanoid());
+    const nymph = this.$nymph;
+    const tnymph = await nymph.startTransaction(transaction);
+    this.$setNymph(tnymph);
+    tilmeld = enforceTilmeld(this);
+
+    let preGuid = this.guid;
+    let preCdate = this.cdate;
+    let preMdate = this.mdate;
+
+    try {
+      for (let callback of (this.constructor as typeof Group)
+        .beforeSaveCallbacks) {
+        if (callback) {
+          await callback(this);
+        }
+      }
+
+      let ret = await super.$save();
+      if (ret) {
+        this.$originalGroupname = this.$data.groupname;
+      }
+      for (let callback of (this.constructor as typeof Group)
+        .afterSaveCallbacks) {
+        if (callback) {
+          await callback(this);
+        }
+      }
+      ret = await tnymph.commit(transaction);
+      this.$setNymph(nymph);
+      return ret;
+    } catch (e: any) {
+      await tnymph.rollback(transaction);
+      this.guid = preGuid;
+      this.cdate = preCdate;
+      this.mdate = preMdate;
+      this.$setNymph(nymph);
+      throw e;
     }
-    return ret;
   }
 
   /*
@@ -968,7 +1066,7 @@ export default class Group extends AbleObject<GroupData> {
       );
     }
 
-    const transaction = 'tilmeld-delete-' + this.guid;
+    const transaction = 'tilmeld-delete-group-' + this.guid;
     const nymph = this.$nymph;
     const tnymph = await nymph.startTransaction(transaction);
     this.$setNymph(tnymph);
@@ -976,6 +1074,13 @@ export default class Group extends AbleObject<GroupData> {
     const User = tnymph.getEntityClass(UserClass);
 
     try {
+      for (let callback of (this.constructor as typeof Group)
+        .beforeDeleteCallbacks) {
+        if (callback) {
+          await callback(this);
+        }
+      }
+
       // Delete descendants.
       const descendants = await this.$getDescendants();
       if (descendants.length) {
@@ -1035,6 +1140,7 @@ export default class Group extends AbleObject<GroupData> {
             : !(await user.$save())
         ) {
           await tnymph.rollback(transaction);
+          this.$setNymph(nymph);
           return false;
         }
       }
@@ -1042,6 +1148,13 @@ export default class Group extends AbleObject<GroupData> {
       // Delete the group.
       let success = await super.$delete();
       if (success) {
+        for (let callback of (this.constructor as typeof Group)
+          .afterDeleteCallbacks) {
+          if (callback) {
+            await callback(this);
+          }
+        }
+
         success = await tnymph.commit(transaction);
       } else {
         await tnymph.rollback(transaction);
@@ -1070,4 +1183,74 @@ export default class Group extends AbleObject<GroupData> {
     }
     return false;
   }
+
+  public static on<T extends GroupEventType>(
+    event: T,
+    callback: T extends 'checkGroupname'
+      ? TilmeldCheckGroupnameCallback
+      : T extends 'beforeSave'
+        ? TilmeldBeforeGroupSaveCallback
+        : T extends 'afterSave'
+          ? TilmeldAfterGroupSaveCallback
+          : T extends 'beforeDelete'
+            ? TilmeldBeforeGroupDeleteCallback
+            : T extends 'afterDelete'
+              ? TilmeldAfterGroupDeleteCallback
+              : never,
+  ) {
+    const prop = (event + 'Callbacks') as T extends 'checkGroupname'
+      ? 'checkGroupnameCallbacks'
+      : T extends 'beforeSave'
+        ? 'beforeSaveCallbacks'
+        : T extends 'afterSave'
+          ? 'afterSaveCallbacks'
+          : T extends 'beforeDelete'
+            ? 'beforeDeleteCallbacks'
+            : T extends 'afterDelete'
+              ? 'afterDeleteCallbacks'
+              : never;
+    if (!(prop in this)) {
+      throw new Error('Invalid event type.');
+    }
+    // @ts-ignore: The callback should always be the right type here.
+    this[prop].push(callback);
+    return () => this.off(event, callback);
+  }
+
+  public static off<T extends GroupEventType>(
+    event: T,
+    callback: T extends 'checkGroupname'
+      ? TilmeldCheckGroupnameCallback
+      : T extends 'beforeSave'
+        ? TilmeldBeforeGroupSaveCallback
+        : T extends 'afterSave'
+          ? TilmeldAfterGroupSaveCallback
+          : T extends 'beforeDelete'
+            ? TilmeldBeforeGroupDeleteCallback
+            : T extends 'afterDelete'
+              ? TilmeldAfterGroupDeleteCallback
+              : never,
+  ) {
+    const prop = (event + 'Callbacks') as T extends 'checkGroupname'
+      ? 'checkGroupnameCallbacks'
+      : T extends 'beforeSave'
+        ? 'beforeSaveCallbacks'
+        : T extends 'afterSave'
+          ? 'afterSaveCallbacks'
+          : T extends 'beforeDelete'
+            ? 'beforeDeleteCallbacks'
+            : T extends 'afterDelete'
+              ? 'afterDeleteCallbacks'
+              : never;
+    if (!(prop in this)) {
+      return false;
+    }
+    // @ts-ignore: The callback should always be the right type here.
+    const i = this[prop].indexOf(callback);
+    if (i > -1) {
+      // @ts-ignore: The callback should always be the right type here.
+      this[prop].splice(i, 1);
+    }
+    return true;
+  }
 }

package/src/Tilmeld.ts

@@ -696,6 +696,8 @@ export default class Tilmeld implements TilmeldInterface {
    * whether the check passes:
    *
    * - It is a user or group. (True for READ_ACCESS or Tilmeld admins.)
+   * - It is a user or group that belongs to a domain the current user is an
+   *   admin for, and domain support is enabled. (Always true.)
    * - No user is logged in. (Check other AC.)
    * - The entity is the user. (Always true.)
    * - It is the user's primary group. (True for READ_ACCESS.)

package/src/User.ts

@@ -31,10 +31,14 @@ 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
@@ -45,19 +49,39 @@ export type TilmeldCheckUsernameCallback = (
   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 } },
 ) => 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 },
 ) => Promise<void>;
 /**
- * These are run after the authentication checks, but before the login action.
+ * 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>;
+/**
+ * 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,
@@ -67,10 +91,6 @@ export type TilmeldBeforeLoginCallback = (
     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,
 ) => Promise<void>;
@@ -80,6 +100,22 @@ export type TilmeldBeforeLogoutCallback = (
 export type TilmeldAfterLogoutCallback = (
   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 = {
   /**
@@ -211,10 +247,14 @@ export default class User extends AbleObject<UserData> {
   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',
@@ -2504,7 +2544,7 @@ export default class User extends AbleObject<UserData> {
     }
 
     // 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.$setNymph(tnymph);
@@ -2628,6 +2668,13 @@ export default class User extends AbleObject<UserData> {
     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);
@@ -2653,6 +2700,23 @@ export default class User extends AbleObject<UserData> {
 
       this.$descendantGroups = undefined;
       this.$gatekeeperCache = undefined;
+
+      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);
@@ -2712,42 +2776,65 @@ export default class User extends AbleObject<UserData> {
       );
     }
 
-    if (tilmeld.User.current(true).$is(this)) {
-      await this.$logout();
-    }
+    const transaction = 'tilmeld-delete-user-' + this.guid;
+    const nymph = this.$nymph;
+    const tnymph = await nymph.startTransaction(transaction);
+    this.$setNymph(tnymph);
 
-    if (this.$data.group != null && this.$is(this.$data.group.user)) {
-      const transaction = 'tilmeld-delete-' + this.guid;
-      const nymph = this.$nymph;
-      const tnymph = await nymph.startTransaction(transaction);
-      this.$setNymph(tnymph);
+    let success = false;
 
-      // Read the skip ac value here, because super.$delete changes it.
-      const $skipAcWhenDeleting = this.$skipAcWhenDeleting;
+    try {
+      for (let callback of (this.constructor as typeof User)
+        .beforeDeleteCallbacks) {
+        if (callback) {
+          await callback(this);
+        }
+      }
 
-      // Delete the user.
-      let success = await super.$delete();
-      if (!success) {
-        await tnymph.rollback(transaction);
-        this.$setNymph(nymph);
-        return success;
+      if (tilmeld.User.current(true).$is(this)) {
+        await this.$logout();
       }
 
-      // Delete the generated group.
-      success = $skipAcWhenDeleting
-        ? await this.$data.group.$deleteSkipAC()
-        : await this.$data.group.$delete();
+      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;
 
-      if (success) {
-        success = await tnymph.commit(transaction);
+        // 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 {
-        await tnymph.rollback(transaction);
+        success = await super.$delete();
       }
+    } catch (e: any) {
+      await tnymph.rollback(transaction);
       this.$setNymph(nymph);
-      return success;
+      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 {
-      return await super.$delete();
+      await tnymph.rollback(transaction);
     }
+    this.$setNymph(nymph);
+    return success;
   }
 
   /*
@@ -2774,15 +2861,23 @@ export default class User extends AbleObject<UserData> {
         ? TilmeldBeforeRegisterCallback
         : T extends 'afterRegister'
           ? TilmeldAfterRegisterCallback
-          : T extends 'beforeLogin'
-            ? TilmeldBeforeLoginCallback
-            : T extends 'afterLogin'
-              ? TilmeldAfterLoginCallback
-              : T extends 'beforeLogout'
-                ? TilmeldBeforeLogoutCallback
-                : T extends 'afterLogout'
-                  ? TilmeldAfterLogoutCallback
-                  : never,
+          : 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 'checkUsername'
       ? 'checkUsernameCallbacks'
@@ -2790,15 +2885,23 @@ export default class User extends AbleObject<UserData> {
         ? 'beforeRegisterCallbacks'
         : T extends 'afterRegister'
           ? 'afterRegisterCallbacks'
-          : T extends 'beforeLogin'
-            ? 'beforeLoginCallbacks'
-            : T extends 'afterLogin'
-              ? 'afterLoginCallbacks'
-              : T extends 'beforeLogout'
-                ? 'beforeLogoutCallbacks'
-                : T extends 'afterLogout'
-                  ? 'afterLogoutCallbacks'
-                  : never;
+          : 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.');
     }
@@ -2815,15 +2918,23 @@ export default class User extends AbleObject<UserData> {
         ? TilmeldBeforeRegisterCallback
         : T extends 'afterRegister'
           ? TilmeldAfterRegisterCallback
-          : T extends 'beforeLogin'
-            ? TilmeldBeforeLoginCallback
-            : T extends 'afterLogin'
-              ? TilmeldAfterLoginCallback
-              : T extends 'beforeLogout'
-                ? TilmeldBeforeLogoutCallback
-                : T extends 'afterLogout'
-                  ? TilmeldAfterLogoutCallback
-                  : never,
+          : 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 'checkUsername'
       ? 'checkUsernameCallbacks'
@@ -2831,15 +2942,23 @@ export default class User extends AbleObject<UserData> {
         ? 'beforeRegisterCallbacks'
         : T extends 'afterRegister'
           ? 'afterRegisterCallbacks'
-          : T extends 'beforeLogin'
-            ? 'beforeLoginCallbacks'
-            : T extends 'afterLogin'
-              ? 'afterLoginCallbacks'
-              : T extends 'beforeLogout'
-                ? 'beforeLogoutCallbacks'
-                : T extends 'afterLogout'
-                  ? 'afterLogoutCallbacks'
-                  : never;
+          : 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;
     }