@memberjunction/server 0.9.74 → 0.9.75

package/src/auth/exampleNewUserSubClass.ts

@@ -1,71 +1,71 @@
-import { RegisterClass } from "@memberjunction/global";
-import { Metadata, RunView, LogError } from "@memberjunction/core";
-import { NewUserBase } from "./newUsers";
-import { UserCache } from "@memberjunction/sqlserver-dataprovider";
-import { configInfo } from "../config";
-
-/**
- * This example class subclasses the @NewUserBase class and overrides the createNewUser method to create a new person record and then call the base class to create the user record. In this example there is an entity
- * called "Persons" that is mapped to the User table in the core MemberJunction schema. You can sub-class the NewUserBase to do whatever behavior you want and pre-process, post-process or entirely override the base
- * class behavior.
- */
-@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) {
-        try {
-            const md = new Metadata();
-            const contextUser = UserCache.Instance.Users.find(u => u.Email.trim().toLowerCase() === configInfo?.userHandling?.contextUserForNewUserCreation?.trim().toLowerCase())
-            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;
-            }
-
-            const pEntity = md.Entities.find(e => e.Name === 'Persons'); // look up the entity info for the Persons entity
-            if (!pEntity) {
-                LogError('Failed to find Persons entity');
-                return undefined;
-            }
-
-            let personId;
-            // this block of code only executes if we have an entity called Persons
-            const rv = new RunView();
-            const viewResults = await rv.RunView({
-                EntityName: 'Persons',
-                ExtraFilter: `Email = '${email}'`
-            }, contextUser)
-    
-            if (viewResults && viewResults.Success && Array.isArray(viewResults.Results) && viewResults.Results.length > 0) {
-                // we have a match so use it
-                const row = (viewResults.Results as { ID: number }[])[0]; // we know the rows will have an ID number
-                personId = row['ID'];
-            }
-    
-            if (!personId) {
-                // we don't have a match so create a new person record
-                const p = await md.GetEntityObject('Persons', contextUser);
-                p.NewRecord(); // assumes we have an entity called Persons that has FirstName/LastName/Email fields
-                p.FirstName = firstName;
-                p.LastName = lastName;
-                p.Email = email;
-                p.Status = 'active';
-                if (await p.Save()) {
-                    personId = p.ID;
-                }   
-                else {
-                    LogError(`Failed to create new person ${firstName} ${lastName} ${email}`)
-                }
-            }
-    
-            // now call the base class to create the user, and pass in our LinkedRecordType and ID
-            return super.createNewUser(firstName, lastName, email, 'Other', pEntity?.ID, personId);        
-        }
-        catch (e) {
-            LogError(`Error creating new user ${email} ${e}`);
-            return undefined;
-        }
-    }
-}
-
-export function LoadExampleNewUserSubClass() {
-    // do nothing, just having this forces the above class to get registered via its @RegisterClass decorator
+import { RegisterClass } from "@memberjunction/global";
+import { Metadata, RunView, LogError } from "@memberjunction/core";
+import { NewUserBase } from "./newUsers";
+import { UserCache } from "@memberjunction/sqlserver-dataprovider";
+import { configInfo } from "../config";
+
+/**
+ * This example class subclasses the @NewUserBase class and overrides the createNewUser method to create a new person record and then call the base class to create the user record. In this example there is an entity
+ * called "Persons" that is mapped to the User table in the core MemberJunction schema. You can sub-class the NewUserBase to do whatever behavior you want and pre-process, post-process or entirely override the base
+ * class behavior.
+ */
+@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) {
+        try {
+            const md = new Metadata();
+            const contextUser = UserCache.Instance.Users.find(u => u.Email.trim().toLowerCase() === configInfo?.userHandling?.contextUserForNewUserCreation?.trim().toLowerCase())
+            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;
+            }
+
+            const pEntity = md.Entities.find(e => e.Name === 'Persons'); // look up the entity info for the Persons entity
+            if (!pEntity) {
+                LogError('Failed to find Persons entity');
+                return undefined;
+            }
+
+            let personId;
+            // this block of code only executes if we have an entity called Persons
+            const rv = new RunView();
+            const viewResults = await rv.RunView({
+                EntityName: 'Persons',
+                ExtraFilter: `Email = '${email}'`
+            }, contextUser)
+    
+            if (viewResults && viewResults.Success && Array.isArray(viewResults.Results) && viewResults.Results.length > 0) {
+                // we have a match so use it
+                const row = (viewResults.Results as { ID: number }[])[0]; // we know the rows will have an ID number
+                personId = row['ID'];
+            }
+    
+            if (!personId) {
+                // we don't have a match so create a new person record
+                const p = await md.GetEntityObject('Persons', contextUser);
+                p.NewRecord(); // assumes we have an entity called Persons that has FirstName/LastName/Email fields
+                p.FirstName = firstName;
+                p.LastName = lastName;
+                p.Email = email;
+                p.Status = 'active';
+                if (await p.Save()) {
+                    personId = p.ID;
+                }   
+                else {
+                    LogError(`Failed to create new person ${firstName} ${lastName} ${email}`)
+                }
+            }
+    
+            // now call the base class to create the user, and pass in our LinkedRecordType and ID
+            return super.createNewUser(firstName, lastName, email, 'Other', pEntity?.ID, personId);        
+        }
+        catch (e) {
+            LogError(`Error creating new user ${email} ${e}`);
+            return undefined;
+        }
+    }
+}
+
+export function LoadExampleNewUserSubClass() {
+    // do nothing, just having this forces the above class to get registered via its @RegisterClass decorator
 }

package/src/auth/index.ts

@@ -1,136 +1,136 @@
-import { JwtHeader, SigningKeyCallback } from 'jsonwebtoken';
-import jwksClient from 'jwks-rsa';
-import { auth0Domain, auth0WebClientID, configInfo, tenantID, webClientID } from '../config';
-import { UserCache } from '@memberjunction/sqlserver-dataprovider';
-import { DataSource } from 'typeorm';
-import { Metadata, UserInfo } from '@memberjunction/core';
-import { NewUserBase } from './newUsers';
-import { MJGlobal } from '@memberjunction/global';
-
-const missingAzureConfig = !tenantID || !webClientID;
-const missingAuth0Config = !auth0Domain || !auth0WebClientID;
-
-class MissingAuthError extends Error {
-  constructor() {
-    super('Could not find authentication configuration for either MSAL or Auth0 in the server environment variables.');
-    this.name = 'MissingAuthError';
-  }
-}
-
-const issuers = {
-  azure: `https://login.microsoftonline.com/${tenantID}/v2.0`,
-  auth0: `https://${auth0Domain}/`,
-};
-
-export const validationOptions = {
-  [issuers.auth0]: {
-    audience: auth0WebClientID,
-    jwksUri: `https://${auth0Domain}/.well-known/jwks.json`,
-  },
-  [issuers.azure]: {
-    audience: webClientID,
-    jwksUri: `https://login.microsoftonline.com/${tenantID}/discovery/v2.0/keys`,
-  },
-};
-
-export class UserPayload {
-  aio?: string;
-  aud?: string;
-  exp?: number;
-  iat?: number;
-  iss?: string;
-  name?: string;
-  nbf?: number;
-  nonce?: string;
-  oid?: string;
-  preferred_username?: string;
-  rh?: string;
-  sub?: string;
-  tid?: string;
-  uti?: string;
-  ver?: string;
-  // what about an array of roles???
-}
-
-export const getSigningKeys = (issuer: string) => (header: JwtHeader, cb: SigningKeyCallback) => {
-  const jwksUri = validationOptions[issuer].jwksUri;
-  if (missingAuth0Config && missingAzureConfig) {
-    throw new MissingAuthError();
-  }
-  if (missingAuth0Config) {
-    console.warn('Auth0 configuration not found in environment variables');
-  }
-  if (missingAzureConfig) {
-    console.warn('MSAL configuration not found in environment variables');
-  }
-
-  jwksClient({ jwksUri })
-    .getSigningKey(header.kid)
-    .then((key) => {
-      cb(null, 'publicKey' in key ? key.publicKey : key.rsaPublicKey);
-    })
-    .catch((err) => console.error(err));
-};
-
-export const verifyUserRecord = async (email?: string, firstName?: string, lastName?: string, requestDomain?: string, dataSource?: DataSource, attemptCacheUpdateIfNeeded: boolean = true): Promise<UserInfo | undefined> => {
-  if (!email) return undefined;
-
-  let user = UserCache.Instance.Users.find((u) => {
-    if (!u.Email || u.Email.trim() === '') {
-      // this condition should never occur. If it doesn throw a console error including the user id
-      // DB requires non-null but this is just an extra check and we could in theory have a blank string in the DB
-      console.error(`SYSTEM METADATA ISSUE: User ${u.ID} has no email address`);
-      return false;
-    }
-    else
-      return u.Email.toLowerCase().trim() === email.toLowerCase().trim()
-  });
-
-  if (!user) {
-    if (configInfo.userHandling.autoCreateNewUsers && firstName && lastName && requestDomain) {
-      // check to see if the domain that we have a request coming in from matches one of the domains in the autoCreateNewUsersDomains setting
-      const domainMatch: boolean = configInfo.userHandling.newUserAuthorizedDomains.some((domain) => domain.toLowerCase().trim() === requestDomain.toLowerCase().trim());
-      if (domainMatch) {
-        // 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);
-        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();
-          initData.UserRoles = configInfo.userHandling.newUserRoles.map((role) => { return { UserID: initData.ID, RoleName: role } });
-          user = new UserInfo(Metadata.Provider, initData);
-          UserCache.Instance.Users.push(user);
-          console.warn(`   >>> New user ${email} created successfully!`);
-        }
-      }
-      else {
-        console.warn(`User ${email} not found in cache. Request domain '${requestDomain}' does not match any of the domains in the newUserAuthorizedDomains setting. NOT creating a new user.`);
-      }
-    }
-    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...`);
-  
-      const startTime: number = Date.now();
-      await UserCache.Instance.Refresh(dataSource);
-      const endTime: number = Date.now();
-      const elapsed: number = endTime - startTime;
-  
-      // if elapsed time is less than the delay setting, wait for the additional time to achieve the full delay
-      // the below also makes sure we never go more than a 30 second total delay
-      const delay = configInfo.userHandling.updateCacheWhenNotFoundDelay ? (configInfo.userHandling.updateCacheWhenNotFoundDelay < 30000 ? configInfo.userHandling.updateCacheWhenNotFoundDelay : 30000) : 0;
-      if (elapsed < delay)
-        await new Promise(resolve => setTimeout(resolve, delay - elapsed));
-  
-      const finalTime: number = Date.now();
-      const finalElapsed: number = finalTime - startTime;
-  
-      console.log(`   UserCache updated in ${elapsed}ms, total elapsed time of ${finalElapsed}ms including delay of ${delay}ms (if needed). Attempting to find the user again via recursive call to verifyUserRecord()`);
-      return verifyUserRecord(email, firstName, lastName, requestDomain, dataSource, false) // try one more time but do not update cache next time if not found
-    }
-  }
-
-  return user;
-};
+import { JwtHeader, SigningKeyCallback } from 'jsonwebtoken';
+import jwksClient from 'jwks-rsa';
+import { auth0Domain, auth0WebClientID, configInfo, tenantID, webClientID } from '../config';
+import { UserCache } from '@memberjunction/sqlserver-dataprovider';
+import { DataSource } from 'typeorm';
+import { Metadata, UserInfo } from '@memberjunction/core';
+import { NewUserBase } from './newUsers';
+import { MJGlobal } from '@memberjunction/global';
+
+const missingAzureConfig = !tenantID || !webClientID;
+const missingAuth0Config = !auth0Domain || !auth0WebClientID;
+
+class MissingAuthError extends Error {
+  constructor() {
+    super('Could not find authentication configuration for either MSAL or Auth0 in the server environment variables.');
+    this.name = 'MissingAuthError';
+  }
+}
+
+const issuers = {
+  azure: `https://login.microsoftonline.com/${tenantID}/v2.0`,
+  auth0: `https://${auth0Domain}/`,
+};
+
+export const validationOptions = {
+  [issuers.auth0]: {
+    audience: auth0WebClientID,
+    jwksUri: `https://${auth0Domain}/.well-known/jwks.json`,
+  },
+  [issuers.azure]: {
+    audience: webClientID,
+    jwksUri: `https://login.microsoftonline.com/${tenantID}/discovery/v2.0/keys`,
+  },
+};
+
+export class UserPayload {
+  aio?: string;
+  aud?: string;
+  exp?: number;
+  iat?: number;
+  iss?: string;
+  name?: string;
+  nbf?: number;
+  nonce?: string;
+  oid?: string;
+  preferred_username?: string;
+  rh?: string;
+  sub?: string;
+  tid?: string;
+  uti?: string;
+  ver?: string;
+  // what about an array of roles???
+}
+
+export const getSigningKeys = (issuer: string) => (header: JwtHeader, cb: SigningKeyCallback) => {
+  const jwksUri = validationOptions[issuer].jwksUri;
+  if (missingAuth0Config && missingAzureConfig) {
+    throw new MissingAuthError();
+  }
+  if (missingAuth0Config) {
+    console.warn('Auth0 configuration not found in environment variables');
+  }
+  if (missingAzureConfig) {
+    console.warn('MSAL configuration not found in environment variables');
+  }
+
+  jwksClient({ jwksUri })
+    .getSigningKey(header.kid)
+    .then((key) => {
+      cb(null, 'publicKey' in key ? key.publicKey : key.rsaPublicKey);
+    })
+    .catch((err) => console.error(err));
+};
+
+export const verifyUserRecord = async (email?: string, firstName?: string, lastName?: string, requestDomain?: string, dataSource?: DataSource, attemptCacheUpdateIfNeeded: boolean = true): Promise<UserInfo | undefined> => {
+  if (!email) return undefined;
+
+  let user = UserCache.Instance.Users.find((u) => {
+    if (!u.Email || u.Email.trim() === '') {
+      // this condition should never occur. If it doesn throw a console error including the user id
+      // DB requires non-null but this is just an extra check and we could in theory have a blank string in the DB
+      console.error(`SYSTEM METADATA ISSUE: User ${u.ID} has no email address`);
+      return false;
+    }
+    else
+      return u.Email.toLowerCase().trim() === email.toLowerCase().trim()
+  });
+
+  if (!user) {
+    if (configInfo.userHandling.autoCreateNewUsers && firstName && lastName && requestDomain) {
+      // check to see if the domain that we have a request coming in from matches one of the domains in the autoCreateNewUsersDomains setting
+      const domainMatch: boolean = configInfo.userHandling.newUserAuthorizedDomains.some((domain) => domain.toLowerCase().trim() === requestDomain.toLowerCase().trim());
+      if (domainMatch) {
+        // 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);
+        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();
+          initData.UserRoles = configInfo.userHandling.newUserRoles.map((role) => { return { UserID: initData.ID, RoleName: role } });
+          user = new UserInfo(Metadata.Provider, initData);
+          UserCache.Instance.Users.push(user);
+          console.warn(`   >>> New user ${email} created successfully!`);
+        }
+      }
+      else {
+        console.warn(`User ${email} not found in cache. Request domain '${requestDomain}' does not match any of the domains in the newUserAuthorizedDomains setting. NOT creating a new user.`);
+      }
+    }
+    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...`);
+  
+      const startTime: number = Date.now();
+      await UserCache.Instance.Refresh(dataSource);
+      const endTime: number = Date.now();
+      const elapsed: number = endTime - startTime;
+  
+      // if elapsed time is less than the delay setting, wait for the additional time to achieve the full delay
+      // the below also makes sure we never go more than a 30 second total delay
+      const delay = configInfo.userHandling.updateCacheWhenNotFoundDelay ? (configInfo.userHandling.updateCacheWhenNotFoundDelay < 30000 ? configInfo.userHandling.updateCacheWhenNotFoundDelay : 30000) : 0;
+      if (elapsed < delay)
+        await new Promise(resolve => setTimeout(resolve, delay - elapsed));
+  
+      const finalTime: number = Date.now();
+      const finalElapsed: number = finalTime - startTime;
+  
+      console.log(`   UserCache updated in ${elapsed}ms, total elapsed time of ${finalElapsed}ms including delay of ${delay}ms (if needed). Attempting to find the user again via recursive call to verifyUserRecord()`);
+      return verifyUserRecord(email, firstName, lastName, requestDomain, dataSource, false) // try one more time but do not update cache next time if not found
+    }
+  }
+
+  return user;
+};

package/src/auth/newUsers.ts

@@ -1,56 +1,56 @@
-import { LogError, Metadata } from "@memberjunction/core";
-import { RegisterClass } from "@memberjunction/global";
-import { UserCache } from "@memberjunction/sqlserver-dataprovider";
-import { configInfo } from "../config";
-
-@RegisterClass(NewUserBase)
-export class NewUserBase {
-    public async createNewUser(firstName: string, lastName: string, email: string, linkedRecordType: string = 'None', linkedEntityId?: number, linkedEntityRecordId?: number) {
-        try {
-            const md = new Metadata();
-            const contextUser = UserCache.Instance.Users.find(u => u.Email.trim().toLowerCase() === configInfo?.userHandling?.contextUserForNewUserCreation?.trim().toLowerCase())
-            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;
-            }
-            const u = 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()) {
-                // user created, now create however many roles we need to create for this user based on the config settings
-                const ur = await md.GetEntityObject('User Roles', contextUser);
-                let bSuccess: boolean = true;
-                for (const role of configInfo.userHandling.newUserRoles) {
-                    ur.NewRecord();
-                    ur.UserID = u.ID;
-                    ur.RoleName = role;
-                    bSuccess = bSuccess && await ur.Save();
-                }
-                if (!bSuccess) {
-                    LogError(`Failed to create roles for newly created user ${firstName} ${lastName} ${email}`);
-                    return undefined;
-                }
-            }
-            else {
-                LogError(`Failed to create new user ${firstName} ${lastName} ${email}`);
-                return undefined;
-            }
-            return u;        
-        }
-        catch (e) {
-            LogError(e);
-            return undefined;
-        }
-    }
+import { LogError, Metadata } from "@memberjunction/core";
+import { RegisterClass } from "@memberjunction/global";
+import { UserCache } from "@memberjunction/sqlserver-dataprovider";
+import { configInfo } from "../config";
+
+@RegisterClass(NewUserBase)
+export class NewUserBase {
+    public async createNewUser(firstName: string, lastName: string, email: string, linkedRecordType: string = 'None', linkedEntityId?: number, linkedEntityRecordId?: number) {
+        try {
+            const md = new Metadata();
+            const contextUser = UserCache.Instance.Users.find(u => u.Email.trim().toLowerCase() === configInfo?.userHandling?.contextUserForNewUserCreation?.trim().toLowerCase())
+            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;
+            }
+            const u = 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()) {
+                // user created, now create however many roles we need to create for this user based on the config settings
+                const ur = await md.GetEntityObject('User Roles', contextUser);
+                let bSuccess: boolean = true;
+                for (const role of configInfo.userHandling.newUserRoles) {
+                    ur.NewRecord();
+                    ur.UserID = u.ID;
+                    ur.RoleName = role;
+                    bSuccess = bSuccess && await ur.Save();
+                }
+                if (!bSuccess) {
+                    LogError(`Failed to create roles for newly created user ${firstName} ${lastName} ${email}`);
+                    return undefined;
+                }
+            }
+            else {
+                LogError(`Failed to create new user ${firstName} ${lastName} ${email}`);
+                return undefined;
+            }
+            return u;        
+        }
+        catch (e) {
+            LogError(e);
+            return undefined;
+        }
+    }
 }

package/src/cache.ts

@@ -1,10 +1,10 @@
-import { LRUCache } from 'lru-cache';
-
-const oneHourMs = 60 * 60 * 1000;
-
-export const authCache = new LRUCache({
-  max: 50000,
-  ttl: oneHourMs,
-  ttlAutopurge: false,
-});
-
+import { LRUCache } from 'lru-cache';
+
+const oneHourMs = 60 * 60 * 1000;
+
+export const authCache = new LRUCache({
+  max: 50000,
+  ttl: oneHourMs,
+  ttlAutopurge: false,
+});
+