@unchainedshop/core-users 4.0.0-rc.8 → 4.0.0

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,
@@ -47,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;
 };
@@ -58,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
@@ -87,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
@@ -102,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) }, {});
     },
@@ -121,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(
@@ -174,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(
         {
@@ -195,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) {
@@ -207,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);
     },
@@ -244,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;
     },
 
@@ -255,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);
@@ -344,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),
       });
@@ -453,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' });
       }
@@ -502,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);
@@ -536,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: {
@@ -549,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}"`),
       });
@@ -598,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,
@@ -617,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;
 
@@ -653,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 = {
@@ -687,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;
 
@@ -718,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(),
@@ -735,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),
       });
@@ -762,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),
       });
@@ -816,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');

package/src/module/pbkdf2.ts

@@ -5,7 +5,11 @@ const PBKDF2_SALT_LENGTH = 16; // Bytes
 
 export function generateSalt(saltLength = PBKDF2_SALT_LENGTH) {
   const array = new Uint8Array(saltLength);
-  return Buffer.from(crypto.getRandomValues(array)).toString('hex');
+  crypto.getRandomValues(array);
+  // Convert to hex string without using Buffer
+  return Array.from(array)
+    .map((b) => b.toString(16).padStart(2, '0'))
+    .join('');
 }
 
 export async function getDerivedKey(
@@ -30,7 +34,10 @@ export async function getDerivedKey(
     importedKey,
     keyLength,
   );
-  return Buffer.from(bits).toString('hex');
+  // Convert ArrayBuffer to hex string without using Buffer
+  return Array.from(new Uint8Array(bits))
+    .map((b) => b.toString(16).padStart(2, '0'))
+    .join('');
 }
 
 export async function compare(password: string, hash: string, salt: string) {

package/src/module/removeConfidentialServiceHashes.test.ts

@@ -7,7 +7,6 @@ import { User } from '../db/UsersCollection.js';
 describe('removeConfidentialServiceHashes', () => {
   it('Should remove sensitive user credentials ', () => {
     assert.notStrictEqual(user.services, undefined);
-    removeConfidentialServiceHashes(user as unknown as User);
-    assert.strictEqual(user.services, undefined);
+    assert.strictEqual(removeConfidentialServiceHashes(user as unknown as User)?.services, undefined);
   });
 });

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 =