@memberjunction/server 2.112.0 → 2.113.0

package/src/apolloServer/index.ts

@@ -4,7 +4,7 @@ import { Disposable } from 'graphql-ws';
 import { Server } from 'http';
 import { enableIntrospection } from '../config.js';
 import { AppContext } from '../types.js';
-import { Metadata } from '@memberjunction/global';
+import { Metadata } from '@memberjunction/core';
 import { SQLServerDataProvider } from '@memberjunction/sqlserver-dataprovider';
 
 const buildApolloServer = (
@@ -24,7 +24,7 @@ const buildApolloServer = (
             },
           };
         },
-      },
+      } 
     ],
     introspection: enableIntrospection,
     ...configOverride,

package/src/auth/AuthProviderFactory.ts

@@ -1,4 +1,4 @@
-import { AuthProviderConfig } from '@memberjunction/global';
+import { AuthProviderConfig } from '@memberjunction/core';
 import { IAuthProvider } from './IAuthProvider.js';
 import { BaseAuthProvider } from './BaseAuthProvider.js';
 import { MJGlobal } from '@memberjunction/global';
@@ -40,12 +40,16 @@ export class AuthProviderFactory {
       // Use MJGlobal ClassFactory to create the provider instance
       // The provider type in config should match the key used in @RegisterClass
       // The config is passed as a constructor parameter via the spread operator
-      const provider = MJGlobal.Instance.ClassFactory.CreateInstance<BaseAuthProvider>(BaseAuthProvider, config.type.toLowerCase(), config);
-
+      const provider = MJGlobal.Instance.ClassFactory.CreateInstance<BaseAuthProvider>(
+        BaseAuthProvider,
+        config.type.toLowerCase(),
+        config
+      );
+      
       if (!provider) {
         throw new Error(`No provider registered for type: ${config.type}`);
       }
-
+      
       return provider;
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
@@ -62,10 +66,10 @@ export class AuthProviderFactory {
     }
 
     this.providers.set(provider.name, provider);
-
+    
     // Clear issuer cache when registering new provider
     this.issuerCache.clear();
-
+    
     console.log(`Registered auth provider: ${provider.name} with issuer: ${provider.issuer}`);
   }
 
@@ -126,7 +130,9 @@ export class AuthProviderFactory {
     // Get all registrations for BaseAuthProvider from ClassFactory
     const registrations = MJGlobal.Instance.ClassFactory.GetAllRegistrations(BaseAuthProvider);
     // Extract unique keys (provider types) from registrations
-    const providerTypes = registrations.map((reg) => reg.Key).filter((key): key is string => key !== null && key !== undefined);
+    const providerTypes = registrations
+      .map(reg => reg.Key)
+      .filter((key): key is string => key !== null && key !== undefined);
     // Return unique provider types
     return Array.from(new Set(providerTypes));
   }
@@ -143,4 +149,4 @@ export class AuthProviderFactory {
       return false;
     }
   }
-}
+}

package/src/auth/BaseAuthProvider.ts

@@ -1,6 +1,6 @@
 import { JwtHeader, JwtPayload, SigningKeyCallback } from 'jsonwebtoken';
 import jwksClient from 'jwks-rsa';
-import { AuthProviderConfig, AuthUserInfo } from '@memberjunction/global';
+import { AuthProviderConfig, AuthUserInfo } from '@memberjunction/core';
 import { IAuthProvider } from './IAuthProvider.js';
 
 /**
@@ -28,7 +28,7 @@ export abstract class BaseAuthProvider implements IAuthProvider {
       jwksUri: this.jwksUri,
       cache: true,
       cacheMaxEntries: 5,
-      cacheMaxAge: 600000, // 10 minutes
+      cacheMaxAge: 600000 // 10 minutes
     });
   }
 
@@ -43,8 +43,7 @@ export abstract class BaseAuthProvider implements IAuthProvider {
    * Gets the signing key for token verification
    */
   getSigningKey(header: JwtHeader, callback: SigningKeyCallback): void {
-    this.jwksClient
-      .getSigningKey(header.kid)
+    this.jwksClient.getSigningKey(header.kid)
       .then((key) => {
         const signingKey = 'publicKey' in key ? key.publicKey : key.rsaPublicKey;
         callback(null, signingKey);
@@ -69,4 +68,4 @@ export abstract class BaseAuthProvider implements IAuthProvider {
    * Abstract method for extracting user info - must be implemented by each provider
    */
   abstract extractUserInfo(payload: JwtPayload): AuthUserInfo;
-}
+}

package/src/auth/IAuthProvider.ts

@@ -1,5 +1,5 @@
 import { JwtHeader, JwtPayload, SigningKeyCallback } from 'jsonwebtoken';
-import { AuthProviderConfig, AuthUserInfo } from '@memberjunction/global';
+import { AuthProviderConfig, AuthUserInfo } from '@memberjunction/core';
 
 /**
  * Interface for authentication providers in MemberJunction
@@ -46,4 +46,4 @@ export interface IAuthProvider {
    * Checks if a given issuer URL belongs to this provider
    */
   matchesIssuer(issuer: string): boolean;
-}
+}

package/src/auth/exampleNewUserSubClass.ts

@@ -1,5 +1,5 @@
 import { RegisterClass } from '@memberjunction/global';
-import { Metadata, RunView, LogError, EntitySaveOptions } from '@memberjunction/global';
+import { Metadata, RunView, LogError, EntitySaveOptions } from '@memberjunction/core';
 import { NewUserBase } from './newUsers.js';
 import { UserCache } from '@memberjunction/sqlserver-dataprovider';
 import { configInfo } from '../config.js';
@@ -13,14 +13,7 @@ import { configInfo } from '../config.js';
 //       so that your class is actually used.
 //@RegisterClass(NewUserBase, undefined, 1) /*by putting 1 into the priority setting, MJGlobal ClassFactory will use this instead of the base class as that registration had no priority*/
 export class ExampleNewUserSubClass extends NewUserBase {
-  public override async createNewUser(
-    firstName: string,
-    lastName: string,
-    email: string,
-    linkedRecordType: string = 'None',
-    linkedEntityId?: string,
-    linkedEntityRecordId?: string
-  ) {
+  public override async createNewUser(firstName: string, lastName: string, email: string, linkedRecordType: string = 'None', linkedEntityId?: string, linkedEntityRecordId?: string) {
     try {
       const md = new Metadata();
 

package/src/auth/index.ts

@@ -2,7 +2,7 @@ import { JwtHeader, SigningKeyCallback, JwtPayload } from 'jsonwebtoken';
 import { configInfo } from '../config.js';
 import { UserCache } from '@memberjunction/sqlserver-dataprovider';
 import sql from 'mssql';
-import { Metadata, RoleInfo, UserInfo } from '@memberjunction/global';
+import { Metadata, RoleInfo, UserInfo } from '@memberjunction/core';
 import { NewUserBase } from './newUsers.js';
 import { MJGlobal } from '@memberjunction/global';
 import { UserEntity, UserEntityType } from '@memberjunction/core-entities';
@@ -53,14 +53,14 @@ const refreshUserCache = async (dataSource?: sql.ConnectionPool) => {
 export const getValidationOptions = (issuer: string): { audience: string; jwksUri: string } | undefined => {
   const factory = AuthProviderFactory.getInstance();
   const provider = factory.getByIssuer(issuer);
-
+  
   if (!provider) {
     return undefined;
   }
 
   return {
     audience: provider.audience,
-    jwksUri: provider.jwksUri,
+    jwksUri: provider.jwksUri
   };
 };
 
@@ -68,21 +68,18 @@ export const getValidationOptions = (issuer: string): { audience: string; jwksUr
  * Backward compatible validationOptions object
  * @deprecated Use getValidationOptions() or AuthProviderRegistry instead
  */
-export const validationOptions: Record<string, { audience: string; jwksUri: string }> = new Proxy(
-  {},
-  {
-    get: (target, prop: string) => {
-      return getValidationOptions(prop);
-    },
-    has: (target, prop: string) => {
-      return getValidationOptions(prop) !== undefined;
-    },
-    ownKeys: () => {
-      const factory = AuthProviderFactory.getInstance();
-      return factory.getAllProviders().map((p) => p.issuer);
-    },
+export const validationOptions: Record<string, { audience: string; jwksUri: string }> = new Proxy({}, {
+  get: (target, prop: string) => {
+    return getValidationOptions(prop);
+  },
+  has: (target, prop: string) => {
+    return getValidationOptions(prop) !== undefined;
+  },
+  ownKeys: () => {
+    const factory = AuthProviderFactory.getInstance();
+    return factory.getAllProviders().map(p => p.issuer);
   }
-);
+});
 
 export class UserPayload {
   aio?: string;
@@ -111,14 +108,14 @@ export class UserPayload {
  */
 export const getSigningKeys = (issuer: string) => (header: JwtHeader, cb: SigningKeyCallback) => {
   const factory = AuthProviderFactory.getInstance();
-
+  
   // Initialize providers if not already done
   if (!factory.hasProviders()) {
     initializeAuthProviders();
   }
 
   const provider = factory.getByIssuer(issuer);
-
+  
   if (!provider) {
     // Check if we have any providers at all
     if (!factory.hasProviders()) {
@@ -133,9 +130,7 @@ export const getSigningKeys = (issuer: string) => (header: JwtHeader, cb: Signin
 /**
  * Extracts user information from JWT payload using the appropriate provider
  */
-export const extractUserInfoFromPayload = (
-  payload: JwtPayload
-): {
+export const extractUserInfoFromPayload = (payload: JwtPayload): {
   email?: string;
   firstName?: string;
   lastName?: string;
@@ -144,31 +139,31 @@ export const extractUserInfoFromPayload = (
 } => {
   const factory = AuthProviderFactory.getInstance();
   const issuer = payload.iss;
-
+  
   if (!issuer) {
     // Fallback to default extraction
     const preferredUsername = payload.preferred_username as string | undefined;
     return {
-      email: (payload.email as string | undefined) || preferredUsername,
+      email: payload.email as string | undefined || preferredUsername,
       firstName: payload.given_name as string | undefined,
       lastName: payload.family_name as string | undefined,
       fullName: payload.name as string | undefined,
-      preferredUsername,
+      preferredUsername
     };
   }
 
   const provider = factory.getByIssuer(issuer);
-
+  
   if (!provider) {
     // Fallback to default extraction
     const fullName = payload.name as string | undefined;
     const preferredUsername = payload.preferred_username as string | undefined;
     return {
-      email: (payload.email as string | undefined) || preferredUsername,
-      firstName: (payload.given_name as string | undefined) || fullName?.split(' ')[0],
-      lastName: (payload.family_name as string | undefined) || fullName?.split(' ')[1] || fullName?.split(' ')[0],
+      email: payload.email as string | undefined || preferredUsername,
+      firstName: payload.given_name as string | undefined || fullName?.split(' ')[0],
+      lastName: payload.family_name as string | undefined || fullName?.split(' ')[1] || fullName?.split(' ')[0],
       fullName,
-      preferredUsername,
+      preferredUsername
     };
   }
 
@@ -272,4 +267,4 @@ export const verifyUserRecord = async (
 };
 
 // Initialize providers on module load
-initializeAuthProviders();
+initializeAuthProviders();

package/src/auth/initializeProviders.ts

@@ -1,5 +1,5 @@
 import { configInfo } from '../config.js';
-import { AuthProviderConfig, LogError, LogStatus } from '@memberjunction/global';
+import { AuthProviderConfig, LogError, LogStatus } from '@memberjunction/core';
 import { AuthProviderFactory } from './AuthProviderFactory.js';
 
 /**
@@ -7,7 +7,7 @@ import { AuthProviderFactory } from './AuthProviderFactory.js';
  */
 export function initializeAuthProviders(): void {
   const factory = AuthProviderFactory.getInstance();
-
+  
   // Clear any existing providers
   factory.clear();
 
@@ -28,4 +28,4 @@ export function initializeAuthProviders(): void {
   if (!factory.hasProviders()) {
     LogError('No authentication providers configured. Please configure authProviders array in mj.config.cjs');
   }
-}
+}

package/src/auth/newUsers.ts

@@ -1,174 +1,142 @@
-import {
-  ApplicationInfo,
-  EntitySaveOptions,
-  LogError,
-  LogStatus,
-  Metadata,
-  RunView,
-  RunViewResult,
-  UserInfo,
-} from '@memberjunction/global';
-import { RegisterClass } from '@memberjunction/global';
-import { UserCache } from '@memberjunction/sqlserver-dataprovider';
-import { configInfo } from '../config.js';
-import {
-  UserEntity,
-  UserRoleEntity,
-  UserApplicationEntity,
-  UserApplicationEntityEntity,
-  ApplicationEntityType,
-  ApplicationEntityEntityType,
-} from '@memberjunction/core-entities';
+import { ApplicationInfo, EntitySaveOptions, LogError, LogStatus, Metadata, RunView, RunViewResult, UserInfo } from "@memberjunction/core";
+import { RegisterClass } from "@memberjunction/global";
+import { UserCache } from "@memberjunction/sqlserver-dataprovider";
+import { configInfo } from "../config.js";
+import { UserEntity, UserRoleEntity, UserApplicationEntity, UserApplicationEntityEntity, ApplicationEntityType, ApplicationEntityEntityType } from "@memberjunction/core-entities";
 
 export class NewUserBase {
-  public async createNewUser(
-    firstName: string,
-    lastName: string,
-    email: string,
-    linkedRecordType: string = 'None',
-    linkedEntityId?: string,
-    linkedEntityRecordId?: string
-  ): Promise<UserEntity | null> {
-    try {
-      let contextUser: UserInfo | null = null;
-
-      const contextUserForNewUserCreation: string = configInfo?.userHandling?.contextUserForNewUserCreation;
-      if (contextUserForNewUserCreation) {
-        contextUser = UserCache.Instance.UserByName(contextUserForNewUserCreation);
-      }
-
-      if (!contextUser) {
-        LogError(
-          `Failed to load context user ${configInfo?.userHandling?.contextUserForNewUserCreation}, using an existing user with the Owner role instead`
-        );
-
-        contextUser = UserCache.Users.find((user) => user.Type.trim().toLowerCase() === 'owner')!;
-        if (!contextUser) {
-          LogError(`No existing users found in the database with the Owner role, cannot create a new user`);
-          return null;
-        }
-      }
-
-      const md: Metadata = new Metadata();
-      const user = await md.GetEntityObject<UserEntity>('Users', contextUser); // To-Do - change this to be a different defined user for the user creation process
-      user.NewRecord();
-      user.Name = email;
-      user.IsActive = true;
-      user.FirstName = firstName;
-      user.LastName = lastName;
-      user.Email = email;
-      user.Type = 'User';
-      user.LinkedRecordType = linkedRecordType;
-
-      if (linkedEntityId) {
-        user.LinkedEntityID = linkedEntityId;
-      }
-
-      if (linkedEntityRecordId) {
-        user.LinkedEntityRecordID = linkedEntityRecordId;
-      }
-
-      const saveResult: boolean = await user.Save();
-      if (!saveResult) {
-        LogError(`Failed to create new user ${firstName} ${lastName} ${email}:`, undefined, user.LatestResult);
-        return null;
-      }
-
-      if (configInfo.userHandling && configInfo.userHandling.newUserRoles) {
-        // user created, now create however many roles we need to create for this user based on the config settings
-        LogStatus(`User ${user.Email} created, assigning roles`);
-        for (const role of configInfo.userHandling.newUserRoles) {
-          const userRoleEntity: UserRoleEntity = await md.GetEntityObject<UserRoleEntity>('User Roles', contextUser);
-          userRoleEntity.NewRecord();
-          userRoleEntity.UserID = user.ID;
-          const userRole = md.Roles.find((r) => r.Name === role);
-
-          if (!userRole) {
-            LogError(`Role ${role} not found in the database, cannot assign to new user ${user.Name}`);
-            continue;
-          }
-
-          userRoleEntity.RoleID = userRole.ID;
-          const roleSaveResult: boolean = await userRoleEntity.Save();
-          if (roleSaveResult) {
-            LogStatus(`Assigned role ${role} to new user ${user.Name}`);
-          } else {
-            LogError(`Failed to assign role ${role} to new user ${user.Name}:`, undefined, userRoleEntity.LatestResult);
-          }
-        }
-      }
-
-      // Create UserApplication records if specified in the config
-      if (configInfo.userHandling && configInfo.userHandling.CreateUserApplicationRecords) {
-        LogStatus('Creating User Applications for new user: ' + user.Name);
-        for (const appName of configInfo.userHandling.UserApplications) {
-          const toLowerCase: string = appName.trim().toLocaleLowerCase();
-          const application: ApplicationInfo | undefined = md.Applications.find((a) => a.Name.trim().toLocaleLowerCase() === toLowerCase);
-          if (!application) {
-            LogError(`Application ${appName} not found in the Metadata, cannot assign to new user ${user.Name}`);
-            continue;
-          }
-
-          const userApplication: UserApplicationEntity = await md.GetEntityObject<UserApplicationEntity>('User Applications', contextUser);
-          userApplication.NewRecord();
-          userApplication.UserID = user.ID;
-          userApplication.ApplicationID = application.ID;
-          userApplication.IsActive = true;
-
-          const userApplicationSaveResult: boolean = await userApplication.Save();
-          if (userApplicationSaveResult) {
-            LogStatus(`Created User Application ${appName} for new user ${user.Name}`);
-
-            //now create a UserApplicationEntity records for each entity in the application
-            const rv: RunView = new RunView();
-            const rvResult: RunViewResult<ApplicationEntityEntityType> = await rv.RunView(
-              {
-                EntityName: 'Application Entities',
-                ExtraFilter: `ApplicationID = '${application.ID}' and DefaultForNewUser = 1`,
-              },
-              contextUser
-            );
-
-            if (!rvResult.Success) {
-              LogError(
-                `Failed to load Application Entities for Application ${appName} for new user ${user.Name}:`,
-                undefined,
-                rvResult.ErrorMessage
-              );
-              continue;
+    public async createNewUser(firstName: string, lastName: string, email: string, linkedRecordType: string = 'None', linkedEntityId?: string, linkedEntityRecordId?: string): Promise<UserEntity | null> {
+        try {
+            let contextUser: UserInfo | null = null;
+
+            const contextUserForNewUserCreation: string = configInfo?.userHandling?.contextUserForNewUserCreation;
+            if(contextUserForNewUserCreation){
+                contextUser = UserCache.Instance.UserByName(contextUserForNewUserCreation);
             }
 
-            LogStatus(
-              `Creating ${rvResult.Results.length} User Application Entities for User Application ${appName} for new user ${user.Name}`
-            );
-
-            for (const [index, appEntity] of rvResult.Results.entries()) {
-              const userAppEntity: UserApplicationEntityEntity = await md.GetEntityObject<UserApplicationEntityEntity>(
-                'User Application Entities',
-                contextUser
-              );
-              userAppEntity.NewRecord();
-              userAppEntity.UserApplicationID = userApplication.ID;
-              userAppEntity.EntityID = appEntity.EntityID;
-              userAppEntity.Sequence = index;
-
-              const userAppEntitySaveResult: boolean = await userAppEntity.Save();
-              if (userAppEntitySaveResult) {
-                LogStatus(`Created User Application Entity ${appEntity.Entity} for new user ${user.Name}`);
-              } else {
-                LogError(`Failed to create User Application Entity for new user ${user.Name}:`, undefined, userAppEntity.LatestResult);
-              }
+            if (!contextUser) {
+                LogError(`Failed to load context user ${configInfo?.userHandling?.contextUserForNewUserCreation}, using an existing user with the Owner role instead`);
+
+                contextUser = UserCache.Users.find(user => user.Type.trim().toLowerCase() ==='owner')!;
+                if (!contextUser) {
+                    LogError(`No existing users found in the database with the Owner role, cannot create a new user`);
+                    return null;
+                }
+            }
+
+            const md: Metadata = new Metadata();
+            const user = await md.GetEntityObject<UserEntity>('Users', contextUser) // To-Do - change this to be a different defined user for the user creation process
+            user.NewRecord();
+            user.Name = email;
+            user.IsActive = true;
+            user.FirstName = firstName;
+            user.LastName = lastName;
+            user.Email = email;
+            user.Type = 'User';
+            user.LinkedRecordType = linkedRecordType;
+
+            if (linkedEntityId){
+                user.LinkedEntityID = linkedEntityId;
+            }
+
+            if (linkedEntityRecordId){
+                user.LinkedEntityRecordID = linkedEntityRecordId;
             }
-          } else {
-            LogError(`Failed to create User Application ${appName} for new user ${user.Name}:`, undefined, userApplication.LatestResult);
-          }
-        }
-      }
 
-      return user;
-    } catch (e) {
-      LogError(e);
-      return undefined;
+            const saveResult: boolean = await user.Save();
+            if(!saveResult){
+                LogError(`Failed to create new user ${firstName} ${lastName} ${email}:`, undefined, user.LatestResult);
+                return null;
+            }
+
+            if(configInfo.userHandling && configInfo.userHandling.newUserRoles){
+                // user created, now create however many roles we need to create for this user based on the config settings
+                LogStatus(`User ${user.Email} created, assigning roles`);
+                for (const role of configInfo.userHandling.newUserRoles) {
+                    const userRoleEntity: UserRoleEntity = await md.GetEntityObject<UserRoleEntity>('User Roles', contextUser);
+                    userRoleEntity.NewRecord();
+                    userRoleEntity.UserID = user.ID;
+                    const userRole = md.Roles.find(r => r.Name === role);
+
+                    if (!userRole) {
+                        LogError(`Role ${role} not found in the database, cannot assign to new user ${user.Name}`);
+                        continue;
+                    }
+
+                    userRoleEntity.RoleID = userRole.ID;
+                    const roleSaveResult: boolean = await userRoleEntity.Save();
+                    if(roleSaveResult){
+                        LogStatus(`Assigned role ${role} to new user ${user.Name}`);
+                    }
+                    else{
+                        LogError(`Failed to assign role ${role} to new user ${user.Name}:`, undefined, userRoleEntity.LatestResult);
+                    }
+                    
+                }
+            }
+
+            // Create UserApplication records if specified in the config
+            if (configInfo.userHandling && configInfo.userHandling.CreateUserApplicationRecords) {
+                LogStatus("Creating User Applications for new user: " + user.Name);
+                for(const appName of configInfo.userHandling.UserApplications){
+                    const toLowerCase: string = appName.trim().toLocaleLowerCase();
+                    const application: ApplicationInfo | undefined = md.Applications.find(a => a.Name.trim().toLocaleLowerCase() === toLowerCase);
+                    if (!application) {
+                        LogError(`Application ${appName} not found in the Metadata, cannot assign to new user ${user.Name}`);
+                        continue;
+                    }
+
+                    const userApplication: UserApplicationEntity = await md.GetEntityObject<UserApplicationEntity>('User Applications', contextUser);
+                    userApplication.NewRecord();
+                    userApplication.UserID = user.ID;
+                    userApplication.ApplicationID = application.ID;
+                    userApplication.IsActive = true;
+
+                    const userApplicationSaveResult: boolean = await userApplication.Save();
+                    if(userApplicationSaveResult){
+                        LogStatus(`Created User Application ${appName} for new user ${user.Name}`);
+                        
+                        //now create a UserApplicationEntity records for each entity in the application
+                        const rv: RunView = new RunView();
+                        const rvResult: RunViewResult<ApplicationEntityEntityType> = await rv.RunView({
+                            EntityName: 'Application Entities',
+                            ExtraFilter: `ApplicationID = '${application.ID}' and DefaultForNewUser = 1`,
+                        }, contextUser);
+
+                        if(!rvResult.Success){
+                            LogError(`Failed to load Application Entities for Application ${appName} for new user ${user.Name}:`, undefined, rvResult.ErrorMessage);
+                            continue;
+                        }
+
+                        LogStatus(`Creating ${rvResult.Results.length} User Application Entities for User Application ${appName} for new user ${user.Name}`);
+
+                        for(const [index, appEntity] of rvResult.Results.entries()){
+                            const userAppEntity: UserApplicationEntityEntity = await md.GetEntityObject<UserApplicationEntityEntity>('User Application Entities', contextUser);
+                            userAppEntity.NewRecord();
+                            userAppEntity.UserApplicationID = userApplication.ID;
+                            userAppEntity.EntityID = appEntity.EntityID;
+                            userAppEntity.Sequence = index;
+
+                            const userAppEntitySaveResult: boolean = await userAppEntity.Save();
+                            if(userAppEntitySaveResult){
+                                LogStatus(`Created User Application Entity ${appEntity.Entity} for new user ${user.Name}`);
+                            }
+                            else{
+                                LogError(`Failed to create User Application Entity for new user ${user.Name}:`, undefined, userAppEntity.LatestResult);
+                            }
+                        }
+                    }
+                    else{
+                        LogError(`Failed to create User Application ${appName} for new user ${user.Name}:`, undefined, userApplication.LatestResult);
+                    }
+                }
+            }
+
+            return user;
+        }
+        catch (e) {
+            LogError(e);
+            return undefined;
+        }
     }
-  }
 }

package/src/auth/providers/Auth0Provider.ts

@@ -1,6 +1,6 @@
 import { JwtPayload } from 'jsonwebtoken';
 import { RegisterClass } from '@memberjunction/global';
-import { AuthProviderConfig, AuthUserInfo } from '@memberjunction/global';
+import { AuthProviderConfig, AuthUserInfo } from '@memberjunction/core';
 import { BaseAuthProvider } from '../BaseAuthProvider.js';
 
 /**
@@ -21,14 +21,14 @@ export class Auth0Provider extends BaseAuthProvider {
     const fullName = payload.name as string | undefined;
     const firstName = payload.given_name as string | undefined;
     const lastName = payload.family_name as string | undefined;
-    const preferredUsername = (payload.preferred_username as string | undefined) || email;
+    const preferredUsername = payload.preferred_username as string | undefined || email;
 
     return {
       email,
       firstName: firstName || fullName?.split(' ')[0],
       lastName: lastName || fullName?.split(' ')[1] || fullName?.split(' ')[0],
       fullName,
-      preferredUsername,
+      preferredUsername
     };
   }
 
@@ -39,7 +39,7 @@ export class Auth0Provider extends BaseAuthProvider {
     const baseValid = super.validateConfig();
     const hasClientId = !!this.config.clientId;
     const hasDomain = !!this.config.domain;
-
+    
     return baseValid && hasClientId && hasDomain;
   }
-}
+}