@unchainedshop/core-users 4.0.0-rc.2 → 4.0.0-rc.21

package/src/db/UsersCollection.ts

@@ -27,7 +27,7 @@ export interface UserLastLogin {
 export interface PushSubscriptionObject {
   userAgent: string;
   endpoint: string;
-  expirationTime?: number;
+  expirationTime: number;
   keys: {
     auth: string;
     p256dh: string;
@@ -40,7 +40,7 @@ export interface Email {
 }
 
 export type User = {
-  _id?: string;
+  _id: string;
   deleted?: Date;
   avatarId?: string;
   emails: Email[];
@@ -69,6 +69,37 @@ export type UserQuery = mongodb.Filter<User> & {
 export const UsersCollection = async (db: mongodb.Db) => {
   const Users = db.collection<User>('users');
 
+  if (!isDocumentDBCompatModeEnabled()) {
+    await buildDbIndexes<User>(Users, [
+      {
+        index: {
+          _id: 'text',
+          username: 'text',
+          'emails.address': 'text',
+          'profile.displayName': 'text',
+          'lastBillingAddress.firstName': 'text',
+          'lastBillingAddress.lastName': 'text',
+          'lastBillingAddress.company': 'text',
+          'lastBillingAddress.addressLine': 'text',
+          'lastBillingAddress.addressLine2': 'text',
+        } as any,
+        options: {
+          weights: {
+            _id: 9,
+            'emails.address': 7,
+            'profile.displayName': 5,
+            'lastBillingAddress.firstName': 3,
+            'lastBillingAddress.lastName': 3,
+            'lastBillingAddress.company': 1,
+            'lastBillingAddress.addressLine': 1,
+            'lastBillingAddress.addressLine2': 1,
+          },
+          name: 'user_fulltext_search',
+        },
+      },
+    ]);
+  }
+
   await buildDbIndexes<User>(Users, [
     {
       index: {
@@ -137,33 +168,6 @@ export const UsersCollection = async (db: mongodb.Db) => {
         sparse: true,
       },
     },
-
-    !isDocumentDBCompatModeEnabled() && {
-      index: {
-        _id: 'text',
-        username: 'text',
-        'emails.address': 'text',
-        'profile.displayName': 'text',
-        'lastBillingAddress.firstName': 'text',
-        'lastBillingAddress.lastName': 'text',
-        'lastBillingAddress.company': 'text',
-        'lastBillingAddress.addressLine': 'text',
-        'lastBillingAddress.addressLine2': 'text',
-      } as any,
-      options: {
-        weights: {
-          _id: 9,
-          'emails.address': 7,
-          'profile.displayName': 5,
-          'lastBillingAddress.firstName': 3,
-          'lastBillingAddress.lastName': 3,
-          'lastBillingAddress.company': 1,
-          'lastBillingAddress.addressLine': 1,
-          'lastBillingAddress.addressLine2': 1,
-        },
-        name: 'user_fulltext_search',
-      },
-    },
   ]);
 
   return Users;

package/src/module/buildFindSelector.test.ts

@@ -4,7 +4,10 @@ import { buildFindSelector } from './configureUsersModule.js';
 
 describe('buildFindSelector', () => {
   it('Return the correct filter when no parameter is passed', () => {
-    assert.deepStrictEqual(buildFindSelector({}), { deleted: null, guest: { $in: [false, null] } });
+    assert.deepStrictEqual(buildFindSelector({}), {
+      deleted: null,
+      guest: { $ne: true },
+    });
   });
   it('Return the correct filter when no parameter is passed queryString and includeGuest: true', () => {
     assert.deepStrictEqual(buildFindSelector({ queryString: 'Hello world', includeGuests: true }), {
@@ -23,7 +26,7 @@ describe('buildFindSelector', () => {
       {
         'profile.displayName': 'mikael',
         deleted: null,
-        guest: { $in: [false, null] },
+        guest: { $ne: true },
         $text: { $search: 'Hello world' },
       },
     );

package/src/module/configureUsersModule.ts

@@ -1,4 +1,4 @@
-import * as bcrypt from '@node-rs/bcrypt';
+import * as bcrypt from 'bcryptjs';
 import {
   ModuleInput,
   Address,
@@ -20,7 +20,12 @@ import {
 } from '../db/UsersCollection.js';
 import { emit, registerEvents } from '@unchainedshop/events';
 import { systemLocale, SortDirection, SortOption, sha256 } from '@unchainedshop/utils';
-import { UserRegistrationData, userSettings, UserSettingsOptions } from '../users-settings.js';
+import {
+  UserAccountAction,
+  UserRegistrationData,
+  userSettings,
+  UserSettingsOptions,
+} from '../users-settings.js';
 import { configureUsersWebAuthnModule } from './configureUsersWebAuthnModule.js';
 import * as pbkdf2 from './pbkdf2.js';
 
@@ -42,7 +47,7 @@ const USER_EVENTS = [
   'USER_REMOVE',
 ];
 export const removeConfidentialServiceHashes = (rawUser: User): User => {
-  const user = rawUser;
+  const user = { ...rawUser };
   delete user?.services;
   return user;
 };
@@ -53,14 +58,18 @@ export const buildFindSelector = ({
   queryString,
   emailVerified,
   lastLogin,
+  tags,
   ...rest
 }: UserQuery) => {
   const selector: mongodb.Filter<User> = { ...rest };
-  if (!includeDeleted) selector.deleted = null;
-  if (!includeGuests) selector.guest = { $in: [false, null] };
+  if (!includeDeleted) selector.deleted = null as any;
+  if (!includeGuests) selector.guest = { $ne: true };
   if (emailVerified === true) {
     selector['emails.verified'] = true;
   }
+  if (Array.isArray(tags) && tags?.length) {
+    selector.tags = { $in: tags };
+  }
   if (emailVerified === false) {
     // We need to use $ne here else we'd also find users with many emails where one is
     // unverified
@@ -82,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
@@ -97,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) }, {});
     },
@@ -116,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(
@@ -124,7 +134,7 @@ export const configureUsersModule = async ({ db, options }: ModuleInput<UserSett
           'services.email.verificationTokens': {
             $elemMatch: {
               token,
-              when: { $gt: new Date(new Date().getTime() - 1000 * 60 * 60) },
+              when: { $gt: userSettings.earliestValidTokenDate(UserAccountAction.VERIFY_EMAIL) },
             },
           },
         },
@@ -158,7 +168,7 @@ export const configureUsersModule = async ({ db, options }: ModuleInput<UserSett
 
       if (updated.modifiedCount > 0) {
         await emit('USER_ACCOUNT_ACTION', {
-          action: 'email-verified',
+          action: UserAccountAction.EMAIL_VERIFIED,
           address,
           userId,
         });
@@ -169,14 +179,14 @@ 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(
         {
           'services.password.reset': {
             $elemMatch: {
               token,
-              when: { $gt: new Date(new Date().getTime() - 1000 * 60 * 60) },
+              when: { $gt: userSettings.earliestValidTokenDate(UserAccountAction.RESET_PASSWORD) },
             },
           },
         },
@@ -190,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) {
@@ -202,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);
     },
@@ -239,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;
     },
 
@@ -250,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);
@@ -339,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),
       });
@@ -416,7 +426,7 @@ export const configureUsersModule = async ({ db, options }: ModuleInput<UserSett
       );
 
       await emit('USER_ACCOUNT_ACTION', {
-        action: isEnrollment ? 'enroll-account' : 'reset-password',
+        action: isEnrollment ? UserAccountAction.ENROLL_ACCOUNT : UserAccountAction.RESET_PASSWORD,
         userId,
         ...resetToken,
         token: plainToken,
@@ -441,46 +451,53 @@ export const configureUsersModule = async ({ db, options }: ModuleInput<UserSett
       );
 
       await emit('USER_ACCOUNT_ACTION', {
-        action: 'verify-email',
+        action: UserAccountAction.VERIFY_EMAIL,
         userId,
         ...verificationToken,
         token: plainToken,
       });
     },
 
-    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' });
       }
@@ -497,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);
@@ -522,7 +540,7 @@ export const configureUsersModule = async ({ db, options }: ModuleInput<UserSett
           },
         );
         await emit('USER_ACCOUNT_ACTION', {
-          action: 'password-resetted',
+          action: UserAccountAction.PASSWORD_RESETTED,
           userId: updatedUser._id,
         });
 
@@ -531,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: {
@@ -544,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}"`),
       });
@@ -593,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,
@@ -612,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;
 
@@ -648,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 = {
@@ -682,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;
 
@@ -713,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(),
@@ -730,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),
       });
@@ -757,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),
       });
@@ -811,6 +845,13 @@ export const configureUsersModule = async ({ db, options }: ModuleInput<UserSett
         {},
       );
     },
+    existingTags: async (): Promise<string[]> => {
+      const tags = (await Users.distinct('tags', {
+        tags: { $exists: true },
+        deleted: { $exists: false },
+      })) as string[];
+      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;
@@ -86,7 +86,8 @@ export const configureUsersWebAuthnModule = async ({ db }: ModuleInput<any>) =>
       if (!f2l) return null;
 
       const registrationOptions = await f2l.attestationOptions(extensionOptions);
-      const challenge = Buffer.from(registrationOptions.challenge).toString('base64');
+      // Convert challenge to base64 without using Buffer
+      const challenge = btoa(String.fromCharCode(...new Uint8Array(registrationOptions.challenge)));
       const { insertedId } = await WebAuthnCredentialsCreationRequests.insertOne({
         _id: new Date().getTime(),
         challenge,
@@ -102,15 +103,12 @@ 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);
-      const challenge = Buffer.from(loginOptions.challenge).toString('base64');
+      // Convert challenge to base64 without using Buffer
+      const challenge = btoa(String.fromCharCode(...new Uint8Array(loginOptions.challenge)));
       const { insertedId } = await WebAuthnCredentialsCreationRequests.insertOne({
         _id: new Date().getTime(),
         challenge,
@@ -135,6 +133,7 @@ export const configureUsersWebAuthnModule = async ({ db }: ModuleInput<any>) =>
         },
         { sort: { _id: -1 } },
       );
+      if (!request) return null;
 
       const attestationExpectations = {
         challenge: request.challenge,
@@ -184,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');