@memberjunction/server 1.0.6 → 1.0.7

package/src/auth/index.ts

@@ -1,151 +1,151 @@
-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';
-
-export * from './tokenExpiredError';
-
-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) => {
-  if (!validationOptions[issuer]) {
-    throw new Error(`No validation options found for issuer ${issuer}`);
-  }
-
-  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 || configInfo.userHandling.newUserLimitedToAuthorizedDomains === false)) {
-      // check to see if the domain that we have a request coming in from matches one of the domains in the autoCreateNewUsersDomains setting
-      let passesDomainCheck: boolean =  configInfo.userHandling.newUserLimitedToAuthorizedDomains === false /*in this first condition, we are set up to NOT care about domain */
-      if (!passesDomainCheck && requestDomain) {
-          /*in this second condition, we check the domain against authorized domains*/
-          passesDomainCheck = configInfo.userHandling.newUserAuthorizedDomains.some((pattern) => {
-                                    // Convert wildcard domain patterns to regular expressions
-                                    const regex = new RegExp('^' + pattern.toLowerCase().trim().replace(/\./g, '\\.').replace(/\*/g, '.*') + '$');
-                                    return regex.test(requestDomain?.toLowerCase().trim());
-                                  });
-      }
-      
-      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);
-        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. To ignore domain, make sure you set the newUserLimitedToAuthorizedDomains setting to false. In this case we are 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';
+
+export * from './tokenExpiredError';
+
+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) => {
+  if (!validationOptions[issuer]) {
+    throw new Error(`No validation options found for issuer ${issuer}`);
+  }
+
+  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 || configInfo.userHandling.newUserLimitedToAuthorizedDomains === false)) {
+      // check to see if the domain that we have a request coming in from matches one of the domains in the autoCreateNewUsersDomains setting
+      let passesDomainCheck: boolean =  configInfo.userHandling.newUserLimitedToAuthorizedDomains === false /*in this first condition, we are set up to NOT care about domain */
+      if (!passesDomainCheck && requestDomain) {
+          /*in this second condition, we check the domain against authorized domains*/
+          passesDomainCheck = configInfo.userHandling.newUserAuthorizedDomains.some((pattern) => {
+                                    // Convert wildcard domain patterns to regular expressions
+                                    const regex = new RegExp('^' + pattern.toLowerCase().trim().replace(/\./g, '\\.').replace(/\*/g, '.*') + '$');
+                                    return regex.test(requestDomain?.toLowerCase().trim());
+                                  });
+      }
+      
+      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);
+        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. To ignore domain, make sure you set the newUserLimitedToAuthorizedDomains setting to false. In this case we are 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,57 +1,57 @@
-import { LogError, Metadata } from "@memberjunction/core";
-import { RegisterClass } from "@memberjunction/global";
-import { UserCache } from "@memberjunction/sqlserver-dataprovider";
-import { configInfo } from "../config";
-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?: 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 = <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()) {
-                // user created, now create however many roles we need to create for this user based on the config settings
-                const ur = <UserRoleEntity>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";
+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?: 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 = <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()) {
+                // user created, now create however many roles we need to create for this user based on the config settings
+                const ur = <UserRoleEntity>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/auth/tokenExpiredError.ts

@@ -1,12 +1,12 @@
-import { GraphQLError } from 'graphql';
-
-export class TokenExpiredError extends GraphQLError {
-  constructor(expiryDate: Date, message = 'The provided token has expired. Please authenticate again.') {
-    super(message, {
-      extensions: {
-        code: 'JWT_EXPIRED',
-        expiryDate: expiryDate.toISOString(),
-      },
-    });
-  }
-}
+import { GraphQLError } from 'graphql';
+
+export class TokenExpiredError extends GraphQLError {
+  constructor(expiryDate: Date, message = 'The provided token has expired. Please authenticate again.') {
+    super(message, {
+      extensions: {
+        code: 'JWT_EXPIRED',
+        expiryDate: expiryDate.toISOString(),
+      },
+    });
+  }
+}

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,
+});
+

package/src/config.ts

@@ -1,84 +1,89 @@
-import env from 'env-var';
-import fs from 'fs';
-import path from 'path';
-import { z } from 'zod';
-
-export const nodeEnv = env.get('NODE_ENV').asString();
-
-export const dbHost = env.get('DB_HOST').required().asString();
-export const dbPort = env.get('DB_PORT').default('1433').asPortNumber();
-export const dbUsername = env.get('DB_USERNAME').required().asString();
-export const dbPassword = env.get('DB_PASSWORD').required().asString();
-export const dbDatabase = env.get('DB_DATABASE').required().asString();
-export const dbInstanceName = env.get('DB_INSTANCE_NAME').asString();
-export const dbTrustServerCertificate = env.get('DB_TRUST_SERVER_CERTIFICATE').asBool();
-
-export const graphqlPort = env.get('PORT').default('4000').asPortNumber();
-export const graphqlRootPath = env.get('ROOT_PATH').default('/').asString();
-
-export const webClientID = env.get('WEB_CLIENT_ID').asString();
-export const tenantID = env.get('TENANT_ID').asString();
-
-export const enableIntrospection = env.get('ENABLE_INTROSPECTION').default('false').asBool();
-export const websiteRunFromPackage = env.get('WEBSITE_RUN_FROM_PACKAGE').asIntPositive();
-export const userEmailMap = env.get('USER_EMAIL_MAP').default('{}').asJsonObject() as Record<string, string>;
-
-export const ___skipAPIurl = env.get('ASK_SKIP_API_URL').asString();
-export const ___skipAPIOrgId = env.get('ASK_SKIP_ORGANIZATION_ID').asString();
-
-export const auth0Domain = env.get('AUTH0_DOMAIN').asString();
-export const auth0WebClientID = env.get('AUTH0_CLIENT_ID').asString();
-export const auth0ClientSecret = env.get('AUTH0_CLIENT_SECRET').asString();
-
-export const mj_core_schema = env.get('MJ_CORE_SCHEMA').asString();
-
-export const configFile = env.get('CONFIG_FILE').asString();
-
-const userHandlingInfoSchema = z.object({
-  autoCreateNewUsers: z.boolean().optional().default(false),
-  newUserLimitedToAuthorizedDomains: z.boolean().optional().default(false),
-  newUserAuthorizedDomains: z.array(z.string()).optional().default([]),
-  newUserRoles: z.array(z.string()).optional().default([]),
-  updateCacheWhenNotFound: z.boolean().optional().default(false),
-  updateCacheWhenNotFoundDelay: z.number().optional().default(30000),
-  contextUserForNewUserCreation: z.string().optional().default(''),
-});
-
-const databaseSettingsInfoSchema = z.object({
-  connectionTimeout: z.number(),
-  requestTimeout: z.number(),
-  metadataCacheRefreshInterval: z.number(),
-});
-
-const viewingSystemInfoSchema = z.object({
-  enableSmartFilters: z.boolean().optional(),
-});
-
-const askSkipInfoSchema = z.object({
-  organizationInfo: z.string().optional(),
-});
-
-const configInfoSchema = z.object({
-  userHandling: userHandlingInfoSchema,
-  databaseSettings: databaseSettingsInfoSchema,
-  viewingSystem: viewingSystemInfoSchema.optional(),
-  askSkip: askSkipInfoSchema.optional(),
-});
-
-export type UserHandlingInfo = z.infer<typeof userHandlingInfoSchema>;
-export type DatabaseSettingsInfo = z.infer<typeof databaseSettingsInfoSchema>;
-export type ViewingSystemSettingsInfo = z.infer<typeof viewingSystemInfoSchema>;
-export type ConfigInfo = z.infer<typeof configInfoSchema>;
-
-export const configInfo: ConfigInfo = loadConfig();
-
-export function loadConfig() {
-  const configPath = configFile ?? path.resolve('config.json');
-
-  if (!fs.existsSync(configPath)) {
-    throw new Error(`Config file ${configPath} does not exist.`);
-  }
-
-  const configData = fs.readFileSync(configPath, 'utf-8');
-  return configInfoSchema.parse(JSON.parse(configData));
-}
+import env from 'env-var';
+import fs from 'fs';
+import path from 'path';
+import { z } from 'zod';
+
+export const nodeEnv = env.get('NODE_ENV').asString();
+
+export const dbHost = env.get('DB_HOST').required().asString();
+export const dbPort = env.get('DB_PORT').default('1433').asPortNumber();
+export const dbUsername = env.get('DB_USERNAME').required().asString();
+export const dbPassword = env.get('DB_PASSWORD').required().asString();
+export const dbDatabase = env.get('DB_DATABASE').required().asString();
+export const dbInstanceName = env.get('DB_INSTANCE_NAME').asString();
+export const dbTrustServerCertificate = env.get('DB_TRUST_SERVER_CERTIFICATE').asBool();
+
+export const graphqlPort = env.get('PORT').default('4000').asPortNumber();
+
+export const ___codeGenAPIURL = env.get('CODEGEN_API_URL').asString();
+export const ___codeGenAPIPort = env.get('CODEGEN_API_PORT').default('3999').asPortNumber();
+export const ___codeGenAPISubmissionDelay = env.get('CODEGEN_API_SUBMISSION_DELAY').default(5000).asIntPositive();
+
+export const graphqlRootPath = env.get('ROOT_PATH').default('/').asString();
+
+export const webClientID = env.get('WEB_CLIENT_ID').asString();
+export const tenantID = env.get('TENANT_ID').asString();
+
+export const enableIntrospection = env.get('ENABLE_INTROSPECTION').default('false').asBool();
+export const websiteRunFromPackage = env.get('WEBSITE_RUN_FROM_PACKAGE').asIntPositive();
+export const userEmailMap = env.get('USER_EMAIL_MAP').default('{}').asJsonObject() as Record<string, string>;
+
+export const ___skipAPIurl = env.get('ASK_SKIP_API_URL').asString();
+export const ___skipAPIOrgId = env.get('ASK_SKIP_ORGANIZATION_ID').asString();
+
+export const auth0Domain = env.get('AUTH0_DOMAIN').asString();
+export const auth0WebClientID = env.get('AUTH0_CLIENT_ID').asString();
+export const auth0ClientSecret = env.get('AUTH0_CLIENT_SECRET').asString();
+
+export const mj_core_schema = env.get('MJ_CORE_SCHEMA').asString();
+
+export const configFile = env.get('CONFIG_FILE').asString();
+
+const userHandlingInfoSchema = z.object({
+  autoCreateNewUsers: z.boolean().optional().default(false),
+  newUserLimitedToAuthorizedDomains: z.boolean().optional().default(false),
+  newUserAuthorizedDomains: z.array(z.string()).optional().default([]),
+  newUserRoles: z.array(z.string()).optional().default([]),
+  updateCacheWhenNotFound: z.boolean().optional().default(false),
+  updateCacheWhenNotFoundDelay: z.number().optional().default(30000),
+  contextUserForNewUserCreation: z.string().optional().default(''),
+});
+
+const databaseSettingsInfoSchema = z.object({
+  connectionTimeout: z.number(),
+  requestTimeout: z.number(),
+  metadataCacheRefreshInterval: z.number(),
+});
+
+const viewingSystemInfoSchema = z.object({
+  enableSmartFilters: z.boolean().optional(),
+});
+
+const askSkipInfoSchema = z.object({
+  organizationInfo: z.string().optional(),
+});
+
+const configInfoSchema = z.object({
+  userHandling: userHandlingInfoSchema,
+  databaseSettings: databaseSettingsInfoSchema,
+  viewingSystem: viewingSystemInfoSchema.optional(),
+  askSkip: askSkipInfoSchema.optional(),
+});
+
+export type UserHandlingInfo = z.infer<typeof userHandlingInfoSchema>;
+export type DatabaseSettingsInfo = z.infer<typeof databaseSettingsInfoSchema>;
+export type ViewingSystemSettingsInfo = z.infer<typeof viewingSystemInfoSchema>;
+export type ConfigInfo = z.infer<typeof configInfoSchema>;
+
+export const configInfo: ConfigInfo = loadConfig();
+
+export function loadConfig() {
+  const configPath = configFile ?? path.resolve('config.json');
+
+  if (!fs.existsSync(configPath)) {
+    throw new Error(`Config file ${configPath} does not exist.`);
+  }
+
+  const configData = fs.readFileSync(configPath, 'utf-8');
+  return configInfoSchema.parse(JSON.parse(configData));
+}