@nymphjs/tilmeld 1.0.0-beta.120 → 1.0.0-beta.122

package/src/Group.ts

@@ -1,12 +1,13 @@
 import crypto from 'node:crypto';
-import type {
-  Nymph,
-  EntityData,
-  EntityJson,
-  EntityPatch,
-  Options,
-  Selector,
-  SerializedEntityData,
+import {
+  type Nymph,
+  type EntityData,
+  type EntityJson,
+  type EntityPatch,
+  type Options,
+  type Selector,
+  type SerializedEntityData,
+  MethodFailedError,
 } from '@nymphjs/nymph';
 import { nanoid } from '@nymphjs/guid';
 import { difference, xor } from 'lodash-es';
@@ -310,18 +311,6 @@ export default class Group extends AbleObject<GroupData> {
     this.$updateDataProtection();
   }
 
-  $setNymph(nymph: Nymph) {
-    this.$nymph = nymph;
-    if (!this.$asleep()) {
-      if (this.$data.user && this.$data.user.$nymph !== nymph) {
-        this.$data.user.$setNymph(nymph);
-      }
-      if (this.$data.parent && this.$data.parent.$nymph !== nymph) {
-        this.$data.parent.$setNymph(nymph);
-      }
-    }
-  }
-
   async $getUniques(): Promise<string[]> {
     const tilmeld = enforceTilmeld(this);
     const uniques = [`u:${this.$data.groupname}`];
@@ -845,7 +834,7 @@ export default class Group extends AbleObject<GroupData> {
   public async $save() {
     let tilmeld = enforceTilmeld(this);
     if (this.$data.groupname == null || !this.$data.groupname.trim().length) {
-      return false;
+      throw new BadUsernameError('Groupname must not be empty.');
     }
 
     // Lowercase the domain part.
@@ -1007,11 +996,13 @@ export default class Group extends AbleObject<GroupData> {
       );
       if (currentPrimary != null && !this.$is(currentPrimary)) {
         currentPrimary.defaultPrimary = false;
-        if (
-          this.$skipAcWhenSaving
-            ? !(await currentPrimary.$saveSkipAC())
-            : !(await currentPrimary.$save())
-        ) {
+        try {
+          if (this.$skipAcWhenSaving) {
+            await currentPrimary.$saveSkipAC();
+          } else {
+            await currentPrimary.$save();
+          }
+        } catch (e: any) {
           throw new CouldNotChangeDefaultPrimaryGroupError(
             'Could not change new user primary group from ' +
               `${currentPrimary.groupname}.`,
@@ -1038,27 +1029,43 @@ export default class Group extends AbleObject<GroupData> {
         }
       }
 
-      let ret = await super.$save();
-      if (ret) {
-        this.$originalGroupname = this.$data.groupname;
-      }
+      await super.$save();
+
+      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);
+      try {
+        await tnymph.rollback(transaction);
+      } catch (e: any) {
+        nymph.config.debugError(
+          'tilmeld',
+          `Rollback of transaction ${transaction} failed, reason: ${e.message}`,
+        );
+      }
       this.guid = preGuid;
       this.cdate = preCdate;
       this.mdate = preMdate;
       this.$setNymph(nymph);
       throw e;
     }
+
+    let committed = false;
+    try {
+      committed = await tnymph.commit(transaction);
+    } catch (e: any) {
+      committed = false;
+    }
+    this.$setNymph(nymph);
+
+    if (!committed) {
+      throw new MethodFailedError('Transaction could not be committed.');
+    }
   }
 
   /*
@@ -1066,7 +1073,7 @@ export default class Group extends AbleObject<GroupData> {
    */
   public async $saveSkipAC() {
     this.$skipAcWhenSaving = true;
-    return await this.$save();
+    await this.$save();
   }
 
   public $tilmeldSaveSkipAC() {
@@ -1109,14 +1116,16 @@ export default class Group extends AbleObject<GroupData> {
       const descendants = await this.$getDescendants();
       if (descendants.length) {
         for (let curGroup of descendants) {
-          if (
-            this.$skipAcWhenDeleting
-              ? !(await curGroup.$deleteSkipAC())
-              : !(await curGroup.$delete())
-          ) {
+          try {
+            if (this.$skipAcWhenDeleting) {
+              await curGroup.$deleteSkipAC();
+            } else {
+              await curGroup.$delete();
+            }
+          } catch (e: any) {
             await tnymph.rollback(transaction);
             this.$setNymph(nymph);
-            return false;
+            throw e;
           }
         }
       }
@@ -1134,14 +1143,16 @@ export default class Group extends AbleObject<GroupData> {
       );
       for (let user of primaryUsers) {
         delete user.group;
-        if (
-          this.$skipAcWhenDeleting
-            ? !(await user.$saveSkipAC())
-            : !(await user.$save())
-        ) {
+        try {
+          if (this.$skipAcWhenDeleting) {
+            await user.$saveSkipAC();
+          } else {
+            await user.$save();
+          }
+        } catch (e: any) {
           await tnymph.rollback(transaction);
           this.$setNymph(nymph);
-          return false;
+          throw e;
         }
       }
 
@@ -1158,38 +1169,52 @@ export default class Group extends AbleObject<GroupData> {
       );
       for (let user of secondaryUsers) {
         user.$delGroup(this);
-        if (
-          this.$skipAcWhenDeleting
-            ? !(await user.$saveSkipAC())
-            : !(await user.$save())
-        ) {
+        try {
+          if (this.$skipAcWhenDeleting) {
+            await user.$saveSkipAC();
+          } else {
+            await user.$save();
+          }
+        } catch (e: any) {
           await tnymph.rollback(transaction);
           this.$setNymph(nymph);
-          return false;
+          throw e;
         }
       }
 
       // 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);
-          }
-        }
+      await super.$delete();
 
-        success = await tnymph.commit(transaction);
-      } else {
-        await tnymph.rollback(transaction);
+      for (let callback of (this.constructor as typeof Group)
+        .afterDeleteCallbacks) {
+        if (callback) {
+          await callback(this);
+        }
       }
-      this.$setNymph(nymph);
-      return success;
     } catch (e: any) {
-      await tnymph.rollback(transaction);
+      try {
+        await tnymph.rollback(transaction);
+      } catch (e: any) {
+        nymph.config.debugError(
+          'tilmeld',
+          `Rollback of transaction ${transaction} failed, reason: ${e.message}`,
+        );
+      }
       this.$setNymph(nymph);
       throw e;
     }
+
+    let committed = false;
+    try {
+      committed = await tnymph.commit(transaction);
+    } catch (e: any) {
+      committed = false;
+    }
+    this.$setNymph(nymph);
+
+    if (!committed) {
+      throw new MethodFailedError('Transaction could not be committed.');
+    }
   }
 
   /*
@@ -1197,7 +1222,7 @@ export default class Group extends AbleObject<GroupData> {
    */
   async $deleteSkipAC() {
     this.$skipAcWhenDeleting = true;
-    return await this.$delete();
+    await this.$delete();
   }
 
   $tilmeldDeleteSkipAC() {

package/src/User.testArtifacts.ts

@@ -0,0 +1,226 @@
+import { type Nymph, EntityUniqueConstraintError } from '@nymphjs/nymph';
+
+import type Tilmeld from './Tilmeld.js';
+import defaults from './conf/defaults.js';
+import { AccessControlError } from './errors/index.js';
+
+export function UserTest(
+  nymph: Nymph,
+  tilmeld: Tilmeld,
+  describe: (name: string, fn: () => void) => void,
+  it: (name: string, fn: () => void) => void,
+) {
+  const User = tilmeld.User;
+  const Group = tilmeld.Group;
+
+  describe('User', () => {
+    beforeAll(async () => {
+      // Ensure the tables exist.
+      try {
+        await User.factoryUsername('user');
+        await Group.factoryGroupname('group');
+      } catch (e) {
+        // ignore
+      }
+    });
+
+    async function makeNewUser() {
+      const newUser = await User.factory();
+
+      newUser.username = 'new-user';
+      newUser.email = 'newuser@localhost';
+      newUser.nameFirst = 'New';
+      newUser.nameLast = 'User';
+      newUser.name = 'New User';
+      newUser.$password('password');
+
+      return newUser;
+    }
+
+    it('new user passes validation', async () => {
+      const validUser = await makeNewUser();
+
+      expect(() => {
+        defaults.validatorUser({ config: defaults } as Tilmeld, validUser);
+      }).not.toThrow();
+    });
+
+    it("doesn't allow unknown keys", async () => {
+      const invalidUser = await makeNewUser();
+
+      // @ts-ignore: testing unknown keys
+      invalidUser.unknown = 'I should cause an error.';
+
+      expect(() => {
+        defaults.validatorUser({ config: defaults } as Tilmeld, invalidUser);
+      }).toThrow('Invalid User:  "unknown" is not allowed');
+    });
+
+    it("doesn't allow duplicate usernames", async () => {
+      tilmeld.config.generatePrimary = false;
+      class NoUsernameCheckUser extends User {
+        public async $checkUsername() {
+          return {
+            result: true,
+            message: 'No problem here!',
+          };
+        }
+      }
+
+      const newUserA = await NoUsernameCheckUser.factory();
+
+      newUserA.username = 'new-user';
+      newUserA.email = 'newusera@localhost';
+      newUserA.nameFirst = 'New';
+      newUserA.nameLast = 'User';
+      newUserA.name = 'New User';
+      newUserA.$password('password');
+
+      await newUserA.$saveSkipAC();
+
+      const newUserB = await NoUsernameCheckUser.factory();
+
+      newUserB.username = 'new-user';
+      newUserB.email = 'newuserb@localhost';
+      newUserB.nameFirst = 'New';
+      newUserB.nameLast = 'User';
+      newUserB.name = 'New User';
+      newUserB.$password('password');
+
+      try {
+        await newUserB.$saveSkipAC();
+
+        throw new Error("Shouldn't get here because of unique constraint.");
+      } catch (e: any) {
+        expect(e).toBeInstanceOf(EntityUniqueConstraintError);
+      }
+
+      await newUserA.$deleteSkipAC();
+
+      tilmeld.config.generatePrimary = true;
+    });
+
+    it("doesn't allow duplicate emails", async () => {
+      tilmeld.config.generatePrimary = false;
+      class NoEmailCheckUser extends User {
+        public async $checkEmail() {
+          return {
+            result: true,
+            message: 'No problem here!',
+          };
+        }
+      }
+
+      const newUserA = await NoEmailCheckUser.factory();
+
+      newUserA.username = 'new-user-a';
+      newUserA.email = 'newuser@localhost';
+      newUserA.nameFirst = 'New';
+      newUserA.nameLast = 'User';
+      newUserA.name = 'New User';
+      newUserA.$password('password');
+
+      await newUserA.$saveSkipAC();
+
+      const newUserB = await NoEmailCheckUser.factory();
+
+      newUserB.username = 'new-user-b';
+      newUserB.email = 'newuser@localhost';
+      newUserB.nameFirst = 'New';
+      newUserB.nameLast = 'User';
+      newUserB.name = 'New User';
+      newUserB.$password('password');
+
+      try {
+        await newUserB.$saveSkipAC();
+
+        throw new Error("Shouldn't get here because of unique constraint.");
+      } catch (e: any) {
+        expect(e).toBeInstanceOf(EntityUniqueConstraintError);
+      }
+
+      await newUserA.$deleteSkipAC();
+
+      tilmeld.config.generatePrimary = true;
+    });
+
+    it('allows a domain user', async () => {
+      const domainAdmin = await User.factory();
+
+      domainAdmin.username = 'admin';
+      domainAdmin.email = 'admin@localhost';
+      domainAdmin.nameFirst = 'Admin';
+      domainAdmin.nameLast = 'User';
+      domainAdmin.name = 'Admin User';
+      domainAdmin.$password('password');
+      domainAdmin.$grant('tilmeld/domain/example.com/admin');
+
+      await domainAdmin.$saveSkipAC();
+
+      // Log in the domain admin.
+      await tilmeld.fillSession(domainAdmin);
+
+      const domainUser = await User.factory();
+
+      domainUser.username = 'new-user@example.com';
+      domainUser.email = 'newuser@localhost';
+      domainUser.nameFirst = 'New';
+      domainUser.nameLast = 'User';
+      domainUser.name = 'New User';
+      domainUser.$password('password');
+
+      await domainUser.$save();
+
+      tilmeld.clearSession();
+
+      for (const user of [domainAdmin, domainUser]) {
+        if (user.guid != null) {
+          await user.$deleteSkipAC();
+        }
+      }
+    });
+
+    it('disallows a domain user with no admin permission', async () => {
+      const domainAdmin = await User.factory();
+
+      domainAdmin.username = 'admin';
+      domainAdmin.email = 'admin@localhost';
+      domainAdmin.nameFirst = 'Admin';
+      domainAdmin.nameLast = 'User';
+      domainAdmin.name = 'Admin User';
+      domainAdmin.$password('password');
+      domainAdmin.$grant('tilmeld/domain/example.com/admin');
+
+      await domainAdmin.$saveSkipAC();
+
+      // Log in the domain admin.
+      await tilmeld.fillSession(domainAdmin);
+
+      const domainUser = await User.factory();
+
+      // The wrong domain name.
+      domainUser.username = 'new-user@example.net';
+      domainUser.email = 'newuser@localhost';
+      domainUser.nameFirst = 'New';
+      domainUser.nameLast = 'User';
+      domainUser.name = 'New User';
+      domainUser.$password('password');
+
+      try {
+        await domainUser.$save();
+
+        throw new Error("Shouldn't get here because of access control.");
+      } catch (e: any) {
+        expect(e).toBeInstanceOf(AccessControlError);
+      }
+
+      tilmeld.clearSession();
+
+      for (const user of [domainAdmin, domainUser]) {
+        if (user.guid != null) {
+          await user.$deleteSkipAC();
+        }
+      }
+    });
+  });
+}