@unchainedshop/core-users 4.0.0-rc.16 → 4.0.0-rc.17

package/src/module/configureUsersModule.ts

@@ -62,8 +62,8 @@ export const buildFindSelector = ({
   ...rest
 }: UserQuery) => {
   const selector: mongodb.Filter<User> = { ...rest };
-  if (!includeDeleted) selector.deleted = null;
-  if (!includeGuests) selector.guest = { $in: [false, null] };
+  if (!includeDeleted) selector.deleted = { $exists: false };
+  if (!includeGuests) selector.guest = { $ne: true };
   if (emailVerified === true) {
     selector['emails.verified'] = true;
   }
@@ -91,12 +91,13 @@ export const buildFindSelector = ({
   return selector;
 };
 
-export const configureUsersModule = async ({ db, options }: ModuleInput<UserSettingsOptions>) => {
+export const configureUsersModule = async (moduleInput: ModuleInput<UserSettingsOptions>) => {
+  const { db, options } = moduleInput;
   userSettings.configureSettings(options || {}, db);
   registerEvents(USER_EVENTS);
   const Users = await UsersCollection(db);
 
-  const webAuthn = await configureUsersWebAuthnModule({ db, options });
+  const webAuthn = await configureUsersWebAuthnModule(moduleInput);
 
   return {
     // Queries
@@ -106,17 +107,17 @@ export const configureUsersModule = async ({ db, options }: ModuleInput<UserSett
       return userCount;
     },
 
-    async findUserById(userId: string): Promise<User> {
+    async findUserById(userId: string) {
       if (!userId) return null;
       return Users.findOne(generateDbFilterById(userId), {});
     },
 
-    async findUserByUsername(username: string): Promise<User> {
+    async findUserByUsername(username: string) {
       if (!username) return null;
       return Users.findOne({ username: insensitiveTrimmedRegexOperator(username) }, {});
     },
 
-    async findUserByEmail(email: string): Promise<User> {
+    async findUserByEmail(email: string) {
       if (!email) return null;
       return Users.findOne({ 'emails.address': insensitiveTrimmedRegexOperator(email) }, {});
     },
@@ -125,7 +126,7 @@ export const configureUsersModule = async ({ db, options }: ModuleInput<UserSett
       userId: string;
       address: string;
       when: Date;
-    }> {
+    } | null> {
       if (!plainToken) return null;
       const token = await sha256(plainToken);
       const user = await Users.findOne(
@@ -178,7 +179,7 @@ export const configureUsersModule = async ({ db, options }: ModuleInput<UserSett
       userId: string;
       address: string;
       when: Date;
-    }> {
+    } | null> {
       const token = await sha256(plainToken);
       const user = await Users.findOne(
         {
@@ -199,7 +200,7 @@ export const configureUsersModule = async ({ db, options }: ModuleInput<UserSett
       };
     },
 
-    async findUserByToken(plainToken: string): Promise<User> {
+    async findUserByToken(plainToken: string) {
       const token = await sha256(plainToken);
 
       if (token) {
@@ -211,10 +212,7 @@ export const configureUsersModule = async ({ db, options }: ModuleInput<UserSett
       return null;
     },
 
-    async findUser(
-      query: UserQuery & { sort?: SortOption[] },
-      findOptions?: mongodb.FindOptions,
-    ): Promise<User> {
+    async findUser(query: UserQuery & { sort?: SortOption[] }, findOptions?: mongodb.FindOptions) {
       const selector = buildFindSelector(query);
       return Users.findOne(selector, findOptions);
     },
@@ -248,7 +246,10 @@ export const configureUsersModule = async ({ db, options }: ModuleInput<UserSett
     },
 
     async userExists({ userId }: { userId: string }): Promise<boolean> {
-      const userCount = await Users.countDocuments({ _id: userId, deleted: null }, { limit: 1 });
+      const userCount = await Users.countDocuments(
+        { _id: userId, deleted: { $exists: false } },
+        { limit: 1 },
+      );
       return userCount === 1;
     },
 
@@ -259,7 +260,7 @@ export const configureUsersModule = async ({ db, options }: ModuleInput<UserSett
       )?.[0];
     },
 
-    userLocale(user: User): Intl.Locale {
+    userLocale(user: User | null): Intl.Locale {
       if (!user?.lastLogin?.locale) return systemLocale;
       try {
         return new Intl.Locale(user.lastLogin.locale);
@@ -348,7 +349,7 @@ export const configureUsersModule = async ({ db, options }: ModuleInput<UserSett
         /* */
       }
 
-      const user = await Users.findOne({ _id: userId }, {});
+      const user = (await Users.findOne({ _id: userId }, {})) as User;
       await emit('USER_CREATE', {
         user: removeConfidentialServiceHashes(user),
       });
@@ -457,39 +458,46 @@ export const configureUsersModule = async ({ db, options }: ModuleInput<UserSett
       });
     },
 
-    addRoles: async (userId: string, roles: string[]): Promise<number> => {
+    addRoles: async (userId: string, roles: string[]) => {
       const selector = generateDbFilterById(userId);
-      const updateResult = await Users.updateOne(selector, {
-        $addToSet: { roles: { $each: roles } },
-      });
+      const user = await Users.findOneAndUpdate(
+        selector,
+        {
+          $addToSet: { roles: { $each: roles } },
+        },
+        { returnDocument: 'after' },
+      );
+
+      if (!user) return null;
 
-      const user = await Users.findOne(selector, {});
       await emit('USER_ADD_ROLES', {
         user: removeConfidentialServiceHashes(user),
       });
 
-      return updateResult.modifiedCount;
+      return user;
     },
 
     async setUsername(userId: string, username: string) {
       if (!(await userSettings.validateUsername(username))) {
         throw new Error(`Username ${username} is invalid`, { cause: 'USERNAME_INVALID' });
       }
-      await Users.updateOne(
+      const user = await Users.findOneAndUpdate(
         { _id: userId },
         {
           $set: {
             username: username.trim(),
           },
         },
+        { returnDocument: 'after' },
       );
-      const user = await Users.findOne({ _id: userId }, {});
+      if (!user) return null;
       await emit('USER_UPDATE_USERNAME', {
         user: removeConfidentialServiceHashes(user),
       });
+      return user;
     },
 
-    async setPassword(userId: string, plainPassword: string): Promise<User> {
+    async setPassword(userId: string, plainPassword: string) {
       if (!(await userSettings.validatePassword(plainPassword))) {
         throw new Error(`Password ***** is invalid`, { cause: 'PASSWORD_INVALID' });
       }
@@ -506,13 +514,14 @@ export const configureUsersModule = async ({ db, options }: ModuleInput<UserSett
         },
         { returnDocument: 'after' },
       );
+      if (!user) return null;
       await emit('USER_UPDATE_PASSWORD', {
         user: removeConfidentialServiceHashes(user),
       });
       return user;
     },
 
-    async resetPassword(token: string, newPassword: string): Promise<User> {
+    async resetPassword(token: string, newPassword: string) {
       const resetToken = await this.findResetToken(token);
       if (!resetToken) return null;
       const updatedUser = await this.setPassword(resetToken.userId, newPassword);
@@ -540,7 +549,7 @@ export const configureUsersModule = async ({ db, options }: ModuleInput<UserSett
       return updatedUser;
     },
 
-    updateAvatar: async (_id: string, fileId: string): Promise<User> => {
+    updateAvatar: async (_id: string, fileId: string) => {
       const userFilter = generateDbFilterById(_id);
       const modifier = {
         $set: {
@@ -553,44 +562,54 @@ export const configureUsersModule = async ({ db, options }: ModuleInput<UserSett
         returnDocument: 'after',
       });
 
+      if (!user) return null;
       await emit('USER_UPDATE_AVATAR', {
         user: removeConfidentialServiceHashes(user),
       });
       return user;
     },
 
-    updateGuest: async (user: User, guest: boolean): Promise<void> => {
-      const modifier = { $set: { guest } };
-      await Users.updateOne(generateDbFilterById(user._id), modifier);
+    updateGuest: async (user: User, guest: boolean) => {
+      const updatedUser = await Users.findOneAndUpdate(
+        generateDbFilterById(user._id),
+        {
+          $set: { guest },
+        },
+        { returnDocument: 'after' },
+      );
+      if (!updatedUser) return null;
       await emit('USER_UPDATE_GUEST', {
         user: removeConfidentialServiceHashes({
-          ...user,
+          ...updatedUser,
           guest,
         }),
       });
+      return updatedUser;
     },
 
-    updateHeartbeat: async (userId: string, lastLogin: UserLastLogin): Promise<User> => {
-      const modifier = {
-        $set: {
-          lastLogin: {
-            timestamp: new Date(),
-            ...lastLogin,
+    updateHeartbeat: async (userId: string, lastLogin: UserLastLogin) => {
+      const user = await Users.findOneAndUpdate(
+        generateDbFilterById(userId),
+        {
+          $set: {
+            lastLogin: {
+              timestamp: new Date(),
+              ...lastLogin,
+            },
           },
         },
-      };
-
-      const user = await Users.findOneAndUpdate(generateDbFilterById(userId), modifier, {
-        returnDocument: 'after',
-      });
-
+        {
+          returnDocument: 'after',
+        },
+      );
+      if (!user) return null;
       await emit('USER_UPDATE_HEARTBEAT', {
         user: removeConfidentialServiceHashes(user),
       });
       return user;
     },
 
-    markDeleted: async (userId: string): Promise<User> => {
+    markDeleted: async (userId: string) => {
       await db.collection('sessions').deleteMany({
         session: insensitiveTrimmedRegexOperator(`"user":"${userId}"`),
       });
@@ -602,18 +621,21 @@ export const configureUsersModule = async ({ db, options }: ModuleInput<UserSett
             deleted: new Date(),
             emails: [],
             roles: [],
-            profile: null,
-            lastBillingAddress: null,
             services: {},
             pushSubscriptions: [],
-            avatarId: null,
             initialPassword: false,
-            lastContact: null,
-            lastLogin: null,
+          },
+          $unset: {
+            profile: 1,
+            lastBillingAddress: 1,
+            lastContact: 1,
+            lastLogin: 1,
+            avatarId: 1,
           },
         },
         { returnDocument: 'after' },
       );
+      if (!user) return null;
 
       await emit('USER_REMOVE', {
         user,
@@ -621,14 +643,11 @@ export const configureUsersModule = async ({ db, options }: ModuleInput<UserSett
       return user;
     },
 
-    deletePermanently: async ({ userId }: { userId: string }): Promise<User> => {
+    deletePermanently: async ({ userId }: { userId: string }) => {
       return Users.findOneAndDelete({ _id: userId });
     },
 
-    updateProfile: async (
-      userId: string,
-      updatedData: { profile?: UserProfile; meta?: any },
-    ): Promise<User> => {
+    updateProfile: async (userId: string, updatedData: { profile?: UserProfile; meta?: any }) => {
       const userFilter = generateDbFilterById(userId);
       const { meta, profile } = updatedData;
 
@@ -657,16 +676,17 @@ export const configureUsersModule = async ({ db, options }: ModuleInput<UserSett
         returnDocument: 'after',
       });
 
+      if (!user) return null;
       await emit('USER_UPDATE_PROFILE', {
         user: removeConfidentialServiceHashes(user),
       });
       return user;
     },
 
-    updateLastBillingAddress: async (_id: string, lastBillingAddress: Address): Promise<User> => {
+    updateLastBillingAddress: async (_id: string, lastBillingAddress: Address) => {
       const userFilter = generateDbFilterById(_id);
       const user = await Users.findOne(userFilter, {});
-
+      if (!user) return null;
       if (!lastBillingAddress) return user;
 
       const modifier = {
@@ -691,18 +711,17 @@ export const configureUsersModule = async ({ db, options }: ModuleInput<UserSett
         returnDocument: 'after',
       });
 
-      if (updatedUser) {
-        await emit('USER_UPDATE_BILLING_ADDRESS', {
-          user: removeConfidentialServiceHashes(updatedUser),
-        });
-      }
-
+      if (!updatedUser) return null;
+      await emit('USER_UPDATE_BILLING_ADDRESS', {
+        user: removeConfidentialServiceHashes(updatedUser),
+      });
       return updatedUser;
     },
 
-    updateLastContact: async (_id: string, lastContact: Contact): Promise<User> => {
+    updateLastContact: async (_id: string, lastContact: Contact) => {
       const userFilter = generateDbFilterById(_id);
       const user = await Users.findOne(userFilter, {});
+      if (!user) return null;
       const profile = user.profile || {};
       const isGuest = !!user.guest;
 
@@ -722,13 +741,14 @@ export const configureUsersModule = async ({ db, options }: ModuleInput<UserSett
         returnDocument: 'after',
       });
 
+      if (!updatedUser) return null;
       await emit('USER_UPDATE_LAST_CONTACT', {
         user: removeConfidentialServiceHashes(user),
       });
       return updatedUser;
     },
 
-    updateRoles: async (_id: string, roles: string[]): Promise<User> => {
+    updateRoles: async (_id: string, roles: string[]) => {
       const modifier = {
         $set: {
           updated: new Date(),
@@ -739,23 +759,27 @@ export const configureUsersModule = async ({ db, options }: ModuleInput<UserSett
       const user = await Users.findOneAndUpdate(generateDbFilterById(_id), modifier, {
         returnDocument: 'after',
       });
-
+      if (!user) return null;
       await emit('USER_UPDATE_ROLE', {
         user: removeConfidentialServiceHashes(user),
       });
       return user;
     },
 
-    updateTags: async (_id: string, tags: string[]): Promise<User> => {
-      const modifier = {
-        $set: {
-          updated: new Date(),
-          tags,
+    updateTags: async (_id: string, tags: string[]) => {
+      const user = await Users.findOneAndUpdate(
+        generateDbFilterById(_id),
+        {
+          $set: {
+            updated: new Date(),
+            tags,
+          },
         },
-      };
-      const user = await Users.findOneAndUpdate(generateDbFilterById(_id), modifier, {
-        returnDocument: 'after',
-      });
+        {
+          returnDocument: 'after',
+        },
+      );
+      if (!user) return null;
       await emit('USER_UPDATE_TAGS', {
         user: removeConfidentialServiceHashes(user),
       });
@@ -766,11 +790,12 @@ export const configureUsersModule = async ({ db, options }: ModuleInput<UserSett
       selector: mongodb.Filter<User>,
       modifier: mongodb.UpdateFilter<User>,
       updateOptions?: mongodb.FindOneAndUpdateOptions,
-    ): Promise<User> => {
+    ) => {
       const user = await Users.findOneAndUpdate(selector, modifier, {
         ...updateOptions,
         returnDocument: 'after',
       });
+      if (!user) return null;
       await emit('USER_UPDATE', {
         user: removeConfidentialServiceHashes(user),
       });
@@ -825,10 +850,7 @@ export const configureUsersModule = async ({ db, options }: ModuleInput<UserSett
         tags: { $exists: true },
         deleted: { $exists: false },
       })) as string[];
-      return tags
-        .filter(Boolean)
-        .map((t) => t.trim())
-        .filter(Boolean);
+      return tags.filter(Boolean).toSorted();
     },
   };
 };

package/src/module/configureUsersWebAuthnModule.ts

@@ -6,7 +6,7 @@ import type { PublicKeyCredentialCreationOptions, PublicKeyCredentialRequestOpti
 
 const logger = createLogger('unchained:core-users');
 
-const { ROOT_URL, EMAIL_WEBSITE_NAME } = process.env;
+const { ROOT_URL = 'http://localhost:4010', EMAIL_WEBSITE_NAME = 'Unchained' } = process.env;
 
 type SerializedOptions<T> = Omit<T, 'challenge' | 'requestId'> & {
   challenge: string;
@@ -103,11 +103,7 @@ export const configureUsersWebAuthnModule = async ({ db }: ModuleInput<any>) =>
       } as SerializedOptions<PublicKeyCredentialCreationOptions>;
     },
 
-    createCredentialRequestOptions: async (
-      origin: string,
-      username?: string,
-      extensionOptions?: any,
-    ) => {
+    createCredentialRequestOptions: async (origin: string, username: string, extensionOptions?: any) => {
       if (!f2l) return null;
 
       const loginOptions = await f2l.assertionOptions(extensionOptions);
@@ -137,6 +133,7 @@ export const configureUsersWebAuthnModule = async ({ db }: ModuleInput<any>) =>
         },
         { sort: { _id: -1 } },
       );
+      if (!request) return null;
 
       const attestationExpectations = {
         challenge: request.challenge,
@@ -186,6 +183,7 @@ export const configureUsersWebAuthnModule = async ({ db }: ModuleInput<any>) =>
         },
         { sort: { _id: -1 } },
       );
+      if (!request) return null;
 
       const id = Buffer.from(credentials.id, 'base64');
       const authenticatorData = Buffer.from(credentials.response.authenticatorData, 'base64');

package/src/users-settings.ts

@@ -1,6 +1,5 @@
 import { insensitiveTrimmedRegexOperator, mongodb } from '@unchainedshop/mongodb';
 import { User } from './db/UsersCollection.js';
-
 export interface UserRegistrationData extends Partial<User> {
   email?: string;
   password: string | null;
@@ -14,22 +13,6 @@ export enum UserAccountAction {
   PASSWORD_RESETTED = 'password-resetted',
   EMAIL_VERIFIED = 'email-verified',
 }
-export interface UserSettingsOptions {
-  mergeUserCartsOnLogin?: boolean;
-  autoMessagingAfterUserCreation?: boolean;
-  /**
-   * Function to calculate the earliest valid token date. Defaults to 1h if not set.
-   * @param type The type of user account action.
-   * @returns A date. All tokens created after that date are considered valid.
-   */
-  earliestValidTokenDate?: (
-    type: UserAccountAction.VERIFY_EMAIL | UserAccountAction.RESET_PASSWORD,
-  ) => Date;
-  validateEmail?: (email: string) => Promise<boolean>;
-  validateUsername?: (username: string) => Promise<boolean>;
-  validateNewUser?: (user: UserRegistrationData) => Promise<UserRegistrationData>;
-  validatePassword?: (password: string) => Promise<boolean>;
-}
 export interface UserSettings {
   mergeUserCartsOnLogin: boolean;
   autoMessagingAfterUserCreation: boolean;
@@ -43,14 +26,37 @@ export interface UserSettings {
   configureSettings: (options: UserSettingsOptions, db: mongodb.Db) => void;
 }
 
+export type UserSettingsOptions = Omit<Partial<UserSettings>, 'configureSettings'>;
+
+const defaultAutoMessagingAfterUserCreation = true;
+const defaultMergeUserCartsOnLogin = true;
+
+const defaultEarliestValidTokenDate = () => {
+  // 1 hour ago
+  return new Date(new Date().getTime() - 1000 * 60 * 60);
+};
+
+const defaultValidateNewUser = async (user: UserRegistrationData) => {
+  return {
+    ...user,
+    username: user.username?.trim().toLowerCase(),
+    email: user.email?.trim().toLowerCase(),
+    password: user.password ?? null,
+  };
+};
+
+const defaultValidatePassword = async (password: string) => {
+  return password?.length >= 8;
+};
+
 export const userSettings: UserSettings = {
-  autoMessagingAfterUserCreation: null,
-  mergeUserCartsOnLogin: null,
-  earliestValidTokenDate: null,
-  validateEmail: null,
-  validateUsername: null,
-  validateNewUser: null,
-  validatePassword: null,
+  autoMessagingAfterUserCreation: defaultAutoMessagingAfterUserCreation,
+  mergeUserCartsOnLogin: defaultMergeUserCartsOnLogin,
+  earliestValidTokenDate: defaultEarliestValidTokenDate,
+  validateNewUser: defaultValidateNewUser,
+  validateEmail: () => Promise.resolve(true),
+  validateUsername: () => Promise.resolve(true),
+  validatePassword: () => Promise.resolve(true),
 
   configureSettings: (
     {
@@ -61,17 +67,9 @@ export const userSettings: UserSettings = {
       validateUsername,
       validateNewUser,
       validatePassword,
-    }: UserSettingsOptions,
+    },
     db: mongodb.Db,
   ) => {
-    const defaultAutoMessagingAfterUserCreation = true;
-    const defaultMergeUserCartsOnLogin = true;
-
-    const defaultEarliestValidTokenDate = () => {
-      // 1 hour ago
-      return new Date(new Date().getTime() - 1000 * 60 * 60);
-    };
-
     const defaultValidateEmail = async (rawEmail: string) => {
       if (!rawEmail?.includes?.('@')) return false;
       const emailAlreadyExists = await db
@@ -88,18 +86,6 @@ export const userSettings: UserSettings = {
       if (usernameAlreadyExists) return false;
       return true;
     };
-    const defaultValidateNewUser = async (user: UserRegistrationData) => {
-      return {
-        ...user,
-        username: user.username?.trim().toLowerCase(),
-        email: user.email?.trim().toLowerCase(),
-        password: user.password ?? null,
-      };
-    };
-
-    const defaultValidatePassword = async (password: string) => {
-      return password?.length >= 8;
-    };
 
     userSettings.mergeUserCartsOnLogin = mergeUserCartsOnLogin ?? defaultMergeUserCartsOnLogin;
     userSettings.autoMessagingAfterUserCreation =

package/tsconfig.json

@@ -3,7 +3,8 @@
   "compilerOptions": {
     "declarationDir": "./lib",
     "rootDir": "./src",
-    "outDir": "./lib"
+    "outDir": "./lib",
+    
   },
   "exclude": ["**/*.test.ts", "**/*.test.js", "tests", "lib"]
 }