@memberjunction/server 2.111.1 → 2.112.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/core';
+import { Metadata } from '@memberjunction/global';
 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/core';
+import { AuthProviderConfig } from '@memberjunction/global';
 import { IAuthProvider } from './IAuthProvider.js';
 import { BaseAuthProvider } from './BaseAuthProvider.js';
 import { MJGlobal } from '@memberjunction/global';
@@ -40,16 +40,12 @@ 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);
@@ -66,10 +62,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}`);
   }
 
@@ -130,9 +126,7 @@ 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));
   }
@@ -149,4 +143,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/core';
+import { AuthProviderConfig, AuthUserInfo } from '@memberjunction/global';
 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,7 +43,8 @@ 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);
@@ -68,4 +69,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/core';
+import { AuthProviderConfig, AuthUserInfo } from '@memberjunction/global';
 
 /**
  * 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/core';
+import { Metadata, RunView, LogError, EntitySaveOptions } from '@memberjunction/global';
 import { NewUserBase } from './newUsers.js';
 import { UserCache } from '@memberjunction/sqlserver-dataprovider';
 import { configInfo } from '../config.js';
@@ -13,7 +13,14 @@ 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/core';
+import { Metadata, RoleInfo, UserInfo } from '@memberjunction/global';
 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,18 +68,21 @@ 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;
@@ -108,14 +111,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()) {
@@ -130,7 +133,9 @@ 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;
@@ -139,31 +144,31 @@ export const extractUserInfoFromPayload = (payload: JwtPayload): {
 } => {
   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,
     };
   }
 
@@ -267,4 +272,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/core';
+import { AuthProviderConfig, LogError, LogStatus } from '@memberjunction/global';
 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,142 +1,174 @@
-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";
+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';
 
 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);
-                    }
-                    
-                }
+  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;
             }
 
-            // 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);
-                    }
-                }
+            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);
+              }
             }
-
-            return user;
-        }
-        catch (e) {
-            LogError(e);
-            return undefined;
+          } 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/core';
+import { AuthProviderConfig, AuthUserInfo } from '@memberjunction/global';
 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;
   }
-}
+}