@memberjunction/server 2.12.0 → 2.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memberjunction/server",
-  "version": "2.12.0",
+  "version": "2.13.0",
   "description": "MemberJunction: This project provides API access via GraphQL to the common data store.",
   "main": "./dist/index.js",
   "types": "./src/index.ts",
@@ -22,27 +22,27 @@
   "dependencies": {
     "@apollo/server": "^4.9.1",
     "@graphql-tools/utils": "^10.0.1",
-    "@memberjunction/actions": "2.12.0",
-    "@memberjunction/ai": "2.12.0",
-    "@memberjunction/ai-mistral": "2.12.0",
-    "@memberjunction/ai-openai": "2.12.0",
-    "@memberjunction/ai-vectors-pinecone": "2.12.0",
-    "@memberjunction/aiengine": "2.12.0",
-    "@memberjunction/core": "2.12.0",
-    "@memberjunction/core-actions": "2.12.0",
-    "@memberjunction/core-entities": "2.12.0",
-    "@memberjunction/data-context": "2.12.0",
-    "@memberjunction/data-context-server": "2.12.0",
-    "@memberjunction/doc-utils": "2.12.0",
-    "@memberjunction/entity-communications-server": "2.12.0",
-    "@memberjunction/external-change-detection": "2.12.0",
-    "@memberjunction/global": "2.12.0",
-    "@memberjunction/queue": "2.12.0",
-    "@memberjunction/skip-types": "2.12.0",
-    "@memberjunction/sqlserver-dataprovider": "2.12.0",
-    "@memberjunction/graphql-dataprovider": "2.12.0",
-    "@memberjunction/storage": "2.12.0",
-    "@memberjunction/templates": "2.12.0",
+    "@memberjunction/actions": "2.13.0",
+    "@memberjunction/ai": "2.13.0",
+    "@memberjunction/ai-mistral": "2.13.0",
+    "@memberjunction/ai-openai": "2.13.0",
+    "@memberjunction/ai-vectors-pinecone": "2.13.0",
+    "@memberjunction/aiengine": "2.13.0",
+    "@memberjunction/core": "2.13.0",
+    "@memberjunction/core-actions": "2.13.0",
+    "@memberjunction/core-entities": "2.13.0",
+    "@memberjunction/data-context": "2.13.0",
+    "@memberjunction/data-context-server": "2.13.0",
+    "@memberjunction/doc-utils": "2.13.0",
+    "@memberjunction/entity-communications-server": "2.13.0",
+    "@memberjunction/external-change-detection": "2.13.0",
+    "@memberjunction/global": "2.13.0",
+    "@memberjunction/queue": "2.13.0",
+    "@memberjunction/skip-types": "2.13.0",
+    "@memberjunction/sqlserver-dataprovider": "2.13.0",
+    "@memberjunction/graphql-dataprovider": "2.13.0",
+    "@memberjunction/storage": "2.13.0",
+    "@memberjunction/templates": "2.13.0",
     "@types/cors": "^2.8.13",
     "@types/jsonwebtoken": "9.0.6",
     "@types/node": "20.14.2",

package/src/auth/index.ts

@@ -3,9 +3,10 @@ import jwksClient from 'jwks-rsa';
 import { auth0Domain, auth0WebClientID, configInfo, tenantID, webClientID } from '../config.js';
 import { UserCache } from '@memberjunction/sqlserver-dataprovider';
 import { DataSource } from 'typeorm';
-import { Metadata, UserInfo } from '@memberjunction/core';
+import { Metadata, RoleInfo, UserInfo } from '@memberjunction/core';
 import { NewUserBase } from './newUsers.js';
 import { MJGlobal } from '@memberjunction/global';
+import { UserEntity, UserEntityType } from '@memberjunction/core-entities';
 
 export { TokenExpiredError } from './tokenExpiredError.js';
 
@@ -120,15 +121,22 @@ export const verifyUserRecord = async (
       if (passesDomainCheck) {
         // we have a domain from the request that matches one of the domains provided by the configuration, so we will create a new user
         console.warn(`User ${email} not found in cache. Attempting to create a new user...`);
-        const newUserCreator: NewUserBase = <NewUserBase>MJGlobal.Instance.ClassFactory.CreateInstance(NewUserBase); // this will create the object that handles creating the new user for us
-        const newUser = await newUserCreator.createNewUser(firstName, lastName, email);
+        const newUserCreator: NewUserBase = MJGlobal.Instance.ClassFactory.CreateInstance<NewUserBase>(NewUserBase); // this will create the object that handles creating the new user for us
+        const newUser: UserEntity | null = await newUserCreator.createNewUser(firstName, lastName, email);
         if (newUser) {
           // new user worked! we already have the stuff we need for the cache, so no need to go to the DB now, just create a new UserInfo object and use the return value from the createNewUser method
           // to init it, including passing in the role list for the user.
-          const initData: any = newUser.GetAll();
+          const md: Metadata = new Metadata();
+
+          const initData: UserEntityType & {UserRoles: {UserID: string, RoleName: string, RoleID: string}[] } = newUser.GetAll();
+          
           initData.UserRoles = configInfo.userHandling.newUserRoles.map((role) => {
-            return { UserID: initData.ID, RoleName: role };
+            const roleInfo: RoleInfo | undefined = md.Roles.find((r) => r.Name === role);
+            const roleID: string = roleInfo ? roleInfo.ID : "";
+            
+            return { UserID: initData.ID, RoleName: role, RoleID: roleID };
           });
+
           user = new UserInfo(Metadata.Provider, initData);
           UserCache.Instance.Users.push(user);
           console.warn(`   >>> New user ${email} created successfully!`);
@@ -139,6 +147,7 @@ export const verifyUserRecord = async (
         );
       }
     }
+
     if (!user && configInfo.userHandling.updateCacheWhenNotFound && dataSource && attemptCacheUpdateIfNeeded) {
       // if we get here that means in the above, if we were attempting to create a new user, it did not work, or it wasn't attempted and we have a config that asks us to auto update the cache
       console.warn(`User ${email} not found in cache. Updating cache in attempt to find the user...`);

package/src/auth/newUsers.ts

@@ -1,4 +1,4 @@
-import { LogError, Metadata } from "@memberjunction/core";
+import { LogError, LogStatus, Metadata, UserInfo } from "@memberjunction/core";
 import { RegisterClass } from "@memberjunction/global";
 import { UserCache } from "@memberjunction/sqlserver-dataprovider";
 import { configInfo } from "../config.js";
@@ -6,49 +6,73 @@ import { UserEntity, UserRoleEntity } from "@memberjunction/core-entities";
 
 @RegisterClass(NewUserBase)
 export class NewUserBase {
-    public async createNewUser(firstName: string, lastName: string, email: string, linkedRecordType: string = 'None', linkedEntityId?: string, linkedEntityRecordId?: string) {
+    public async createNewUser(firstName: string, lastName: string, email: string, linkedRecordType: string = 'None', linkedEntityId?: string, linkedEntityRecordId?: string): Promise<UserEntity | null> {
         try {
-            const md = new Metadata();
-            const contextUser = UserCache.Instance.Users.find(u => u.Email.trim().toLowerCase() === configInfo?.userHandling?.contextUserForNewUserCreation?.trim().toLowerCase())
+            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}, if you've not specified this on your config.json you must do so. This is the user that is contextually used for creating a new user record dynamically.`);
-                return undefined;
+                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;
             }
-            const u = <UserEntity>await md.GetEntityObject('Users', contextUser) // To-Do - change this to be a different defined user for the user creation process
-            u.NewRecord();
-            u.Name = email;
-            u.IsActive = true;
-            u.FirstName = firstName;
-            u.LastName = lastName;
-            u.Email = email;
-            u.Type = 'User';
-            u.LinkedRecordType = linkedRecordType;
-            if (linkedEntityId)
-                u.LinkedEntityID = linkedEntityId;
-            if (linkedEntityRecordId)
-                u.LinkedEntityRecordID = linkedEntityRecordId;
-
-            if (await u.Save()) {
+
+            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
-                const ur = await md.GetEntityObject<UserRoleEntity>('User Roles', contextUser);
-                let bSuccess: boolean = true;
+                LogStatus(`User ${user.Email} created, assigning roles`);
                 for (const role of configInfo.userHandling.newUserRoles) {
-                    ur.NewRecord();
-                    ur.UserID = u.ID;
-                    const roleID = md.Roles.find(r => r.Name === role)?.ID;
-                    ur.RoleID = roleID;
-                    bSuccess = bSuccess && await ur.Save();
-                }
-                if (!bSuccess) {
-                    LogError(`Failed to create roles for newly created user ${firstName} ${lastName} ${email}`);
-                    return undefined;
+                    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){
+                        LogError(`Failed to assign role ${role} to new user ${user.Name}:`, undefined, userRoleEntity.LatestResult);
+                    }
                 }
             }
-            else {
-                LogError(`Failed to create new user ${firstName} ${lastName} ${email}`);
-                return undefined;
-            }
-            return u;
+
+            return user;
         }
         catch (e) {
             LogError(e);